puppet 0.24.4 → 0.24.5

data/conf/redhat/puppet.spec

@@ -7,7 +7,7 @@
 
 Summary: A network tool for managing many disparate systems
 Name: puppet
-Version: 0.24.4
+Version: 0.24.5
 Release: 1%{?dist}
 License: GPLv2+
 Group: System Environment/Base
@@ -157,6 +157,9 @@ fi
 rm -rf %{buildroot}
 
 %changelog
+* Mon Jul 22 2008 James Turnbull <james@lovedthanlost.net> - 0.24.5-1
+- New version
+
 * Sat Dec 22 2007 David Lutterkort <dlutter@redhat.com> - 0.24.1-1
 - New version
 

data/conf/redhat/server.init

@@ -62,6 +62,11 @@ restart() {
   start
 }
 
+genconfig() {
+  echo -n $"Generate configuration puppetmaster: "
+  $PUPPETMASTER $PUPPETMASTER_OPTS --genconfig
+}
+
 case "$1" in
   start)
 	start
@@ -79,8 +84,11 @@ case "$1" in
 	status $PUPPETMASTER
         RETVAL=$?
 	;;
+  genconfig)
+	genconfig
+	;;
   *)
-	echo $"Usage: $0 {start|stop|status|restart|reload|force-reload|condrestart}"
+	echo $"Usage: $0 {start|stop|status|restart|reload|force-reload|condrestart|genconfig}"
 	exit 1
 esac
 

data/ext/autotest/Rakefile

@@ -0,0 +1,8 @@
+dest = File.expand_path("~/.autotest")
+file dest => ["config", "Rakefile"] do
+    sh "cp config #{dest}"
+end
+
+task :install => dest
+
+task :default => :install

data/ext/autotest/config

@@ -0,0 +1,43 @@
+# vim: syntax=ruby
+# From http://pastie.caboo.se/115692, linked from rickbradley
+
+require 'autotest/redgreen'
+require 'autotest/timestamp'
+
+Autotest.send(:alias_method, :real_find_files, :find_files)
+Autotest.send(:define_method, :find_files) do |*args| 
+  real_find_files.reject do |k, v|
+    if (ENV['AUTOTEST'] and !ENV['AUTOTEST'].empty?)
+      !Regexp.new(ENV['AUTOTEST']).match(k)
+    end
+  end
+end
+
+module Autotest::Growl
+
+  def self.growl title, msg, img, pri=0, sticky="" 
+    system "growlnotify -n autotest --image #{img} -p #{pri} -m #{msg.inspect} #{title} #{sticky}" 
+  end
+
+  Autotest.add_hook :ran_command do |at|
+    image_root = "~/.autotest_images" 
+    results = [at.results].flatten.join("\n")
+    output = results.slice(/(\d+)\stests,\s(\d+)\sassertions,\s(\d+)\sfailures,\s(\d+)\serrors/)
+    if output
+      if $~[3].to_i > 0 || $~[4].to_i > 0
+        growl "FAIL", "#{output}", "#{image_root}/fail.png", 2
+      else
+        growl "Pass", "#{output}", "#{image_root}/pass.png" 
+      end
+    end
+
+    output = results.slice(/(\d+)\sexamples,\s(\d+)\sfailures?(,\s+\d+\s+pending)?/)
+    if output
+      if $~[2].to_i > 0 || $~[4].to_i > 0
+        growl "FAIL", "#{output}", "#{image_root}/fail.png", 2
+      else
+        growl "Pass", "#{output}", "#{image_root}/pass.png" 
+      end
+    end
+  end
+end

data/ext/autotest/readme.rst

@@ -0,0 +1,16 @@
+Autotest is a simple tool that automatically links tests with the files being
+tested, and runs tests automatically when either the test or code has changed.
+
+If you are running on a Mac and have growlnotify_ installed, install the
+ZenTest_ gem, then copy the ``config`` file to ``~/.autotest`` (or just
+run ``rake`` in this directory).
+
+Once you have ``autotest`` installed, change to the root of your Puppet
+git repository and run ``autotest`` with no arguments.  To refresh the list
+of files to scan, hit ``^c`` (that is, control-c).
+
+It's recommended you leave this running in another terminal during all
+development, preferably on another monitor.
+
+.. _zentest: http://www.zenspider.com/ZSS/Products/ZenTest/
+.. _growlnotify: http://growl.info/extras.php

data/{examples/root → ext}/bin/sleeper

@@ -1,4 +1,4 @@
-#!/usr/bin/ruby -w
+#!/usr/bin/env ruby -w
 
 ###
 # sleep indefinitely as a debug

data/ext/emacs/puppet-mode.el

@@ -2,59 +2,52 @@
 ;;; puppet-mode.el
 ;;; 
 ;;; Author: lutter
-;;; Description: A simple mode for editing puppet manifests
+;;; Author: Russ Allbery <rra@stanford.edu>
 ;;;
+;;; Description: A simple mode for editing puppet manifests
 
-(defconst puppet-mode-version "0.0.1")
+(defconst puppet-mode-version "0.2")
 
 (defvar puppet-mode-abbrev-table nil
   "Abbrev table in use in puppet-mode buffers.")
 
 (define-abbrev-table 'puppet-mode-abbrev-table ())
 
-(defvar puppet-mode-map nil "Keymap used in puppet mode.")
+(defcustom puppet-indent-level 2
+  "*Indentation of Puppet statements."
+  :type 'integer :group 'puppet)
 
-(if puppet-mode-map
-    nil
-   (setq puppet-mode-map (make-sparse-keymap))
-;;   (define-key puppet-mode-map "{" 'puppet-electric-brace)
-;;   (define-key puppet-mode-map "}" 'puppet-electric-brace)
-;;   (define-key puppet-mode-map "\e\C-a" 'puppet-beginning-of-defun)
-;;   (define-key puppet-mode-map "\e\C-e" 'puppet-end-of-defun)
-;;   (define-key puppet-mode-map "\e\C-b" 'puppet-backward-sexp)
-;;   (define-key puppet-mode-map "\e\C-f" 'puppet-forward-sexp)
-;;   (define-key puppet-mode-map "\e\C-p" 'puppet-beginning-of-block)
-;;   (define-key puppet-mode-map "\e\C-n" 'puppet-end-of-block)
-;;   (define-key puppet-mode-map "\e\C-h" 'puppet-mark-defun)
-;;   (define-key puppet-mode-map "\e\C-q" 'puppet-indent-exp)
-;;   (define-key puppet-mode-map "\t" 'puppet-indent-command)
-;;   (define-key puppet-mode-map "\C-c\C-e" 'puppet-insert-end)
-;;   (define-key puppet-mode-map "\C-j" 'puppet-reindent-then-newline-and-indent)
-  (define-key puppet-mode-map "\C-m" 'newline))
+(defcustom puppet-include-indent 2
+  "*Indentation of continued Puppet include statements."
+  :type 'integer :group 'puppet)
 
-(defvar puppet-mode-syntax-table nil
-  "Syntax table in use in puppet-mode buffers.")
+(defvar puppet-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map "\C-j" 'newline-and-indent)
+    (define-key map "\C-m" 'newline-and-indent)
+    map)
+  "Key map used in puppet-mode buffers.")
 
-(if puppet-mode-syntax-table
-    ()
-  (setq puppet-mode-syntax-table (make-syntax-table))
-  (modify-syntax-entry ?\' "\"" puppet-mode-syntax-table)
-  (modify-syntax-entry ?\" "\"" puppet-mode-syntax-table)
-  (modify-syntax-entry ?# "<" puppet-mode-syntax-table)
-  (modify-syntax-entry ?\n ">" puppet-mode-syntax-table)
-  (modify-syntax-entry ?\\ "\\" puppet-mode-syntax-table)
-  (modify-syntax-entry ?$ "." puppet-mode-syntax-table)
-  (modify-syntax-entry ?- "_" puppet-mode-syntax-table)
-  (modify-syntax-entry ?> "." puppet-mode-syntax-table)
-  (modify-syntax-entry ?= "." puppet-mode-syntax-table)
-  (modify-syntax-entry ?\; "." puppet-mode-syntax-table)
-  (modify-syntax-entry ?\( "()" puppet-mode-syntax-table)
-  (modify-syntax-entry ?\) ")(" puppet-mode-syntax-table)
-  (modify-syntax-entry ?\{ "(}" puppet-mode-syntax-table)
-  (modify-syntax-entry ?\} "){" puppet-mode-syntax-table)
-  (modify-syntax-entry ?\[ "(]" puppet-mode-syntax-table)
-  (modify-syntax-entry ?\] ")[" puppet-mode-syntax-table)
-  )
+(defvar puppet-mode-syntax-table
+  (let ((table (make-syntax-table)))
+    (modify-syntax-entry ?\' "\"" table)
+    (modify-syntax-entry ?\" "\"" table)
+    (modify-syntax-entry ?#  "<"  table)
+    (modify-syntax-entry ?\n ">"  table)
+    (modify-syntax-entry ?\\ "\\" table)
+    (modify-syntax-entry ?$  "."  table)
+    (modify-syntax-entry ?-  "_"  table)
+    (modify-syntax-entry ?>  "."  table)
+    (modify-syntax-entry ?=  "."  table)
+    (modify-syntax-entry ?\; "."  table)
+    (modify-syntax-entry ?\( "()" table)
+    (modify-syntax-entry ?\) ")(" table)
+    (modify-syntax-entry ?\{ "(}" table)
+    (modify-syntax-entry ?\} "){" table)
+    (modify-syntax-entry ?\[ "(]" table)
+    (modify-syntax-entry ?\] ")[" table)
+    table)
+  "Syntax table in use in puppet-mode buffers.")
 
 (defcustom puppet-indent-tabs-mode nil
   "*Indentation can insert tabs in puppet mode if this is non-nil."
@@ -64,36 +57,43 @@
   "*Indentation column of comments."
   :type 'integer :group 'puppet)
 
-(defun puppet-mode-variables ()
-  (set-syntax-table puppet-mode-syntax-table)
-  (setq local-abbrev-table puppet-mode-abbrev-table)
-  ;(make-local-variable 'indent-line-function)
-  ;(setq indent-line-function 'ruby-indent-line)
-  (make-local-variable 'require-final-newline)
-  (setq require-final-newline t)
-  (make-variable-buffer-local 'comment-start)
-  (setq comment-start "# ")
-  (make-variable-buffer-local 'comment-end)
-  (setq comment-end "")
-  (make-variable-buffer-local 'comment-column)
-  (setq comment-column puppet-comment-column)
-  (make-variable-buffer-local 'comment-start-skip)
-  (setq comment-start-skip "#+ *")
-  (setq indent-tabs-mode puppet-indent-tabs-mode)
-  (make-local-variable 'parse-sexp-ignore-comments)
-  (setq parse-sexp-ignore-comments t)
-  (make-local-variable 'paragraph-start)
-  (setq paragraph-start (concat "$\\|" page-delimiter))
-  (make-local-variable 'paragraph-separate)
-  (setq paragraph-separate paragraph-start)
-  (make-local-variable 'paragraph-ignore-fill-prefix)
-  (setq paragraph-ignore-fill-prefix t))
+(defun puppet-count-matches (re start end)
+  "The same as Emacs 22 count-matches, for portability to other versions
+of Emacs."
+  (save-excursion
+    (let ((n 0))
+      (goto-char start)
+      (while (re-search-forward re end t) (setq n (1+ n)))
+      n)))
 
 (defun puppet-comment-line-p ()
   "Return non-nil iff this line is a comment."
   (save-excursion
-    (beginning-of-line)
-    (looking-at (format "\\s-*%s" comment-start))))
+    (save-match-data
+      (beginning-of-line)
+      (looking-at (format "\\s-*%s" comment-start)))))
+
+(defun puppet-block-indent ()
+  "If point is in a block, return the indentation of the first line of that
+block (the line containing the opening brace).  Used to set the indentation
+of the closing brace of a block."
+  (save-excursion
+    (save-match-data
+      (let ((opoint (point))
+            (apoint (search-backward "{" nil t)))
+        (when apoint
+          ;; This is a bit of a hack and doesn't allow for strings.  We really
+          ;; want to parse by sexps at some point.
+          (let ((close-braces (puppet-count-matches "}" apoint opoint))
+                (open-braces 0))
+            (while (and apoint (> close-braces open-braces))
+              (setq apoint (search-backward "{" nil t))
+              (when apoint
+                (setq close-braces (puppet-count-matches "}" apoint opoint))
+                (setq open-braces (1+ open-braces)))))
+          (if apoint
+              (current-indentation)
+            nil))))))
 
 (defun puppet-in-array ()
   "If point is in an array, return the position of the opening '[' of
@@ -103,15 +103,36 @@ that array, else return nil."
       (let ((opoint (point))
             (apoint (search-backward "[" nil t)))
         (when apoint
-          ;; An array opens before point.  If it doesn't close before
-          ;; point, then point must be in it.
-          ;; ### TODO: of course, the '[' could be in a string literal,
-          ;; ### in which case this whole idea is bogus.  But baby
-          ;; ### steps, baby steps.  A more robust strategy might be
-          ;; ### to walk backwards by sexps, until hit a wall, then
-          ;; ### inspect the nature of that wall.
-          (if (= (count-matches "\\]" apoint opoint) 0)
-              apoint))))))
+          ;; This is a bit of a hack and doesn't allow for strings.  We really
+          ;; want to parse by sexps at some point.
+          (let ((close-brackets (puppet-count-matches "]" apoint opoint))
+                (open-brackets 0))
+            (while (and apoint (> close-brackets open-brackets))
+              (setq apoint (search-backward "[" nil t))
+              (when apoint
+                (setq close-brackets (puppet-count-matches "]" apoint opoint))
+                (setq open-brackets (1+ open-brackets)))))
+          apoint)))))
+
+(defun puppet-in-include ()
+  "If point is in a continued list of include statements, return the position
+of the initial include plus puppet-include-indent."
+  (save-excursion
+    (save-match-data
+      (let ((include-column nil)
+            (not-found t))
+        (while not-found
+          (forward-line -1)
+          (cond
+           ((bobp)
+            (setq not-found nil))
+           ((looking-at "^\\s-*include\\s-+.*,\\s-*$")
+            (setq include-column
+                  (+ (current-indentation) puppet-include-indent))
+            (setq not-found nil))
+           ((not (looking-at ".*,\\s-*$"))
+            (setq not-found nil))))
+        include-column))))
 
 (defun puppet-indent-line ()
   "Indent current line as puppet code."
@@ -121,6 +142,8 @@ that array, else return nil."
       (indent-line-to 0)                ; First line is always non-indented
     (let ((not-indented t)
           (array-start (puppet-in-array))
+          (include-start (puppet-in-include))
+          (block-indent (puppet-block-indent))
           cur-indent)
       (cond
        (array-start
@@ -155,18 +178,13 @@ that array, else return nil."
           (re-search-forward "\\S-")
           (forward-char -1)
           (setq cur-indent (current-column))))
-       ((looking-at "^[^{\n]*}")
-        ;; This line contains the end of a block, but the block does
-        ;; not also begin on this line, so decrease the indentation.
-        (save-excursion
-          (forward-line -1)
-          (if (looking-at "^.*}")
-              (progn
-                (setq cur-indent (- (current-indentation) 2))
-                (setq not-indented nil))
-            (setq cur-indent (- (current-indentation) 2))))
-        (if (< cur-indent 0)     ; We can't indent past the left margin
-            (setq cur-indent 0)))
+       (include-start
+        (setq cur-indent include-start))
+       ((and (looking-at "^\\s-*}\\s-*$") block-indent)
+        ;; This line contains only a closing brace and we're at the inner
+        ;; block, so we should indent it matching the indentation of the
+        ;; opening brace of the block.
+        (setq cur-indent block-indent))
        (t
         ;; Otherwise, we did not start on a block-ending-only line.
         (save-excursion
@@ -174,123 +192,167 @@ that array, else return nil."
           (while not-indented
             (forward-line -1)
             (cond
+             ;; Comment lines are ignored unless we're at the start of the
+             ;; buffer.
              ((puppet-comment-line-p)
               (if (bobp)
-                  (setq not-indented nil)
-                ;; else ignore the line and continue iterating backwards
-                ))
-             ((looking-at "^.*}") ; indent at the level of the END_ token
+                  (setq not-indented nil)))
+
+             ;; Brace or paren on a line by itself will already be indented to
+             ;; the right level, so we can cheat and stop there.
+             ((looking-at "^\\s-*[\)}]\\s-*")
               (setq cur-indent (current-indentation))
               (setq not-indented nil))
-             ((looking-at "^.*{") ; indent an extra level
-              (setq cur-indent (+ (current-indentation) 2)) 
-              (setq not-indented nil))
-             ((bobp)
-              (setq not-indented nil))
-             )))))
-      (if cur-indent
-          (indent-line-to cur-indent)
-        (indent-line-to 0)))))
 
+             ;; Brace or paren not on a line by itself will be indented one
+             ;; level too much, but don't catch cases where the block is
+             ;; started and closed on the same line.
+             ((looking-at "^[^\n\({]*[\)}]\\s-*$")
+              (setq cur-indent (- (current-indentation) puppet-indent-level))
+              (setq not-indented nil))
 
-;;;###autoload
-(defun puppet-mode ()
-  "Major mode for editing puppet manifests.
+             ;; Indent by one level more than the start of our block.  We lose
+             ;; if there is more than one block opened and closed on the same
+             ;; line but it's still unbalanced; hopefully people don't do that.
+             ((looking-at "^.*{[^\n}]*$")
+              (setq cur-indent (+ (current-indentation) puppet-indent-level)) 
+              (setq not-indented nil))
 
-The variable puppet-indent-level controls the amount of indentation.
-\\{puppet-mode-map}"
-  (interactive)
-  (kill-all-local-variables)
-  (use-local-map puppet-mode-map)
-  (setq mode-name "Puppet")
-  (setq major-mode 'puppet-mode)
-  (puppet-mode-variables)
- ;; Register our indentation function
-  (set (make-local-variable 'indent-line-function) 'puppet-indent-line)  
-  (run-hooks 'puppet-mode-hook))
+             ;; Indent by one level if the line ends with an open paren.
+             ((looking-at "^.*\(\\s-*$")
+              (setq cur-indent (+ (current-indentation) puppet-indent-level)) 
+              (setq not-indented nil))
 
+             ;; Semicolon ends a block for a resource when multiple resources
+             ;; are defined in the same block, but try not to get the case of
+             ;; a complete resource on a single line wrong.
+             ((looking-at "^\\([^'\":\n]\\|\"[^\n\"]*\"\\|'[^\n']'\\)**;\\s-*$")
+              (setq cur-indent (- (current-indentation) puppet-indent-level))
+              (setq not-indented nil))
 
+             ;; Indent an extra level after : since it introduces a resource.
+             ((looking-at "^.*:\\s-*$")
+              (setq cur-indent (+ (current-indentation) puppet-indent-level))
+              (setq not-indented nil))
 
-(cond
- ((featurep 'font-lock)
-  (or (boundp 'font-lock-variable-name-face)
-      (setq font-lock-variable-name-face font-lock-type-face))
+             ;; Start of buffer.
+             ((bobp)
+              (setq not-indented nil)))))
 
-  (setq puppet-font-lock-syntactic-keywords
-        '(
-          ("\\(^\\|[=(,~?:;]\\|\\(^\\|\\s \\)\\(if\\|elsif\\|unless\\|while\\|until\\|when\\|and\\|or\\|&&\\|||\\)\\|g?sub!?\\|scan\\|split!?\\)\\s *\\(/\\)[^/\n\\\\]*\\(\\\\.[^/\n\\\\]*\\)*\\(/\\)"
-           (4 (7 . ?/))
-           (6 (7 . ?/)))
-          ("^\\(=\\)begin\\(\\s \\|$\\)" 1 (7 . nil))
-          ("^\\(=\\)end\\(\\s \\|$\\)" 1 (7 . nil))))
+        ;; If this line contains only a closing paren, we should lose one
+        ;; level of indentation.
+        (if (looking-at "^\\s-*\)\\s-*$")
+            (setq cur-indent (- cur-indent puppet-indent-level)))))
 
-  (cond ((featurep 'xemacs)
-         (put 'puppet-mode 'font-lock-defaults
-              '((puppet-font-lock-keywords)
-                nil nil nil
-                beginning-of-line
-                (font-lock-syntactic-keywords
-                 . puppet-font-lock-syntactic-keywords))))
-        (t
-         (add-hook 'puppet-mode-hook
-            '(lambda ()
-               (make-local-variable 'font-lock-defaults)
-               (make-local-variable 'font-lock-keywords)
-               (make-local-variable 'font-lock-syntax-table)
-               (make-local-variable 'font-lock-syntactic-keywords)
-               (setq font-lock-defaults '((puppet-font-lock-keywords) nil nil))
-               (setq font-lock-keywords puppet-font-lock-keywords)
-               (setq font-lock-syntax-table puppet-font-lock-syntax-table)
-               (setq font-lock-syntactic-keywords puppet-font-lock-syntactic-keywords)))))
+      ;; We've figured out the indentation, so do it.
+      (if (and cur-indent (> cur-indent 0))
+          (indent-line-to cur-indent)
+        (indent-line-to 0)))))
 
-  (defvar puppet-font-lock-syntax-table
-    (let* ((tbl (copy-syntax-table puppet-mode-syntax-table)))
-      (modify-syntax-entry ?_ "w" tbl)
-      tbl))
+(defvar puppet-font-lock-syntax-table
+  (let* ((tbl (copy-syntax-table puppet-mode-syntax-table)))
+    (modify-syntax-entry ?_ "w" tbl)
+    tbl))
 
-  (defvar puppet-font-lock-keywords
-    (list
-     ;; defines
-     '("^\\s *\\(define\\|node\\|class\\)\\s +\\([^( \t\n]+\\)"
-       2 font-lock-function-name-face)
-     ;; include
-     '("^\\s *include\\s +\\([^( \t\n]+\\)"
-       1 font-lock-reference-face)
-     ;; keywords
-     (cons (concat
-            "\\b\\(\\("
-            (mapconcat
-             'identity
-             '("case"
-               "class"
-               "default"
-               "define"
-               "false"
-               "import"
-               "include"
-               "inherits"
-               "node"
-               "true"
-               )
-             "\\|")
-            "\\)\\>\\)")
-           1)
+(defvar puppet-font-lock-keywords
+  (list
+   ;; defines, classes, and nodes
+   '("^\\s *\\(class\\|define\\|node\\)\\s +\\([^( \t\n]+\\)"
+     2 font-lock-function-name-face)
+   ;; inheritence
+   '("\\s +inherits\\s +\\([^( \t\n]+\\)"
+     1 font-lock-function-name-face)
+   ;; include
+   '("\\(^\\|\\s +\\)include\\s +\\(\\([a-zA-Z0-9:_-]+\\(,[ \t\n]*\\)?\\)+\\)"
+     2 font-lock-reference-face)
+   ;; keywords
+   (cons (concat
+          "\\b\\(\\("
+          (mapconcat
+           'identity
+           '("alert"
+             "case"
+             "class"
+             "crit"
+             "debug"
+             "default"
+             "define"
+             "defined"
+             "else"
+             "emerg"
+             "err"
+             "fail"
+             "false"
+             "file"
+             "filebucket"
+             "generate"
+             "if"
+             "import"
+             "include"
+             "info"
+             "inherits"
+             "node"
+             "notice"
+             "realize"
+             "search"
+             "tag"
+             "tagged"
+             "template"
+             "true"
+             "warning"
+             )
+           "\\|")
+          "\\)\\>\\)")
+         1)
      ;; variables
-     '("\\(^\\|[^_:.@$]\\|\\.\\.\\)\\b\\(nil\\|self\\|true\\|false\\)\\>"
+     '("\\(^\\|[^_:.@$]\\)\\b\\(true\\|false\\)\\>"
        2 font-lock-variable-name-face)
-     ;; variables
      '("\\(\\$\\([^a-zA-Z0-9 \n]\\|[0-9]\\)\\)\\W"
        1 font-lock-variable-name-face)
-     '("\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+"
+     '("\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\|:\\)+"
        0 font-lock-variable-name-face)
      ;; usage of types
-     '("^\\s +\\([a-zA-Z-]+\\)\\s +{" 
+     '("^\\s *\\([a-zA-Z_-]+\\)\\s +{"
+       1 font-lock-type-face)
+     ;; overrides and type references
+     '("\\s +\\([A-Z][a-zA-Z_:-]*\\)\\["
        1 font-lock-type-face)
      ;; general delimited string
      '("\\(^\\|[[ \t\n<+(,=]\\)\\(%[xrqQwW]?\\([^<[{(a-zA-Z0-9 \n]\\)[^\n\\\\]*\\(\\\\.[^\n\\\\]*\\)*\\(\\3\\)\\)"
-       (2 font-lock-string-face))
-     )
-    "*Additional expressions to highlight in puppet mode."))
- )
+       (2 font-lock-string-face)))
+  "*Additional expressions to highlight in puppet mode.")
+
+;;;###autoload
+(defun puppet-mode ()
+  "Major mode for editing puppet manifests.
+
+The variable puppet-indent-level controls the amount of indentation.
+\\{puppet-mode-map}"
+  (interactive)
+  (kill-all-local-variables)
+  (use-local-map puppet-mode-map)
+  (setq mode-name "Puppet")
+  (setq major-mode 'puppet-mode)
+  (set-syntax-table puppet-mode-syntax-table)
+  (set (make-local-variable 'local-abbrev-table) puppet-mode-abbrev-table)
+  (set (make-local-variable 'comment-start) "# ")
+  (set (make-local-variable 'comment-start-skip) "#+ *")
+  (set (make-local-variable 'comment-end) "")
+  (set (make-local-variable 'comment-column) puppet-comment-column)
+  (set (make-local-variable 'indent-line-function) 'puppet-indent-line)
+  (set (make-local-variable 'indent-tabs-mode) puppet-indent-tabs-mode)
+  (set (make-local-variable 'require-final-newline) t)
+  (set (make-local-variable 'paragraph-ignore-fill-prefix) t)
+  (set (make-local-variable 'paragraph-start) "\f\\|[ 	]*$")
+  (set (make-local-variable 'paragraph-separate) "[ 	\f]*$")
+  (or (boundp 'font-lock-variable-name-face)
+      (setq font-lock-variable-name-face font-lock-type-face))
+  (set (make-local-variable 'font-lock-keywords) puppet-font-lock-keywords)
+  (set (make-local-variable 'font-lock-multiline) t)
+  (set (make-local-variable 'font-lock-defaults)
+       '((puppet-font-lock-keywords) nil nil))
+  (set (make-local-variable 'font-lock-syntax-table)
+       puppet-font-lock-syntax-table)
+  (run-hooks 'puppet-mode-hook))
 
 (provide 'puppet-mode)