puppet 4.10.0 → 5.0.0

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: 66d908f990904667f0bbdf26bd54808905882ab5
-  data.tar.gz: 42292b5c1448af0dfa713eb6d4843e2f0b9bc98a
-SHA512:
-  metadata.gz: 67f91f562c07ab4aaf09d7db51769ab1ee169fd432a134fd7c0a32417d6c3b02a176192b724af3ab2c7f3461f1e7008c69f69aa592726da36ef7dfe814b69f1c
-  data.tar.gz: 163fd0b9accc9f76749b96a66c60dbbff2e3ffd66de97179f5c5859b2ce5b474fc70a91125985ba780d97b6a5f39983fe1dfddd861fc8cf8b7eec0071c2c81f6

data/bin/extlookup2hiera

@@ -1,56 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'optparse'
-require 'csv'
-
-options = {:in => nil, :out => nil, :format => :yaml}
-
-OptionParser.new do |opts|
-  opts.banner = "Converter for extlookup CSV files into Hiera JSON and YAML files"
-
-  opts.on("--in FILE", "-i", "Input CSV file") do |v|
-    options[:in] = v
-  end
-
-  opts.on("--out FILE", "-o", "Output Hiera file") do |v|
-    options[:out] = v
-  end
-
-  opts.on("--json", "-j", "Create JSON format file") do |v|
-    options[:format] = :json
-  end
-end.parse!
-
-if options[:in].nil? || options[:out].nil?
-  STDERR.puts "Please specify an input and output file with --in and --out"
-  exit 1
-end
-
-unless File.exist?(options[:in])
-  STDERR.puts "Cannot find input file #{options[:in]}"
-  exit 1
-end
-
-csvdata = CSV.read(options[:in])
-hieradata = {}
-
-csvdata.each do |d|
-  d = d.map{|item| item.to_s}
-
-  if d.size > 2
-    hieradata[d[0]] = d[1, d.size].flatten
-  else
-    hieradata[d[0]] = d[1]
-  end
-end
-
-case options[:format]
-when :yaml
-  require 'yaml'
-  File.open(options[:out], "w") {|f| f.write hieradata.to_yaml}
-when :json
-  require 'rubygems'
-  require 'json'
-  File.open(options[:out], "w") {|f| f.write JSON.pretty_generate hieradata}
-end
-

data/ext/emacs/puppet-mode-init.el

@@ -1,6 +0,0 @@
-;;
-;; Setup puppet-mode for autoloading
-;;
-(autoload 'puppet-mode "puppet-mode" "Major mode for editing puppet manifests")
-
-(add-to-list 'auto-mode-alist '("\\.pp\\'" . puppet-mode))

data/ext/emacs/puppet-mode.el

@@ -1,433 +0,0 @@
-;;; puppet-mode.el --- major mode for Puppet manifests
-
-;; Copyright 2006 David Lutterkort
-;; Copyright 2008 Karl Fogel <kfogel@red-bean.com>
-;; Copyright 2008, 2012
-;;     The Board of Trustees of the Leland Stanford Junior University
-
-;; Author: David Lutterkort
-;;	Russ Allbery <rra@stanford.edu>
-;; Maintainer: Russ Allbery <rra@stanford.edu>
-;; Created: 2006-02-07
-;; Version: 1.2
-;; Keywords: languages
-
-;; This file is part of Puppet.
-;;
-;; Licensed under the Apache License, Version 2.0 (the "License"); you may not
-;; use this file except in compliance with the License.  You may obtain a copy
-;; of the License at
-;;
-;;     https://www.apache.org/licenses/LICENSE-2.0
-;;
-;; Unless required by applicable law or agreed to in writing, software
-;; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-;; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-;; License for the specific language governing permissions and limitations
-;; under the License.
-
-;;; Code:
-
-(defconst puppet-mode-version "1.2")
-
-(defvar puppet-mode-abbrev-table nil
-  "Abbrev table in use in puppet-mode buffers.")
-
-(define-abbrev-table 'puppet-mode-abbrev-table ())
-
-(defcustom puppet-indent-level 2
-  "*Indentation of Puppet statements."
-  :type 'integer :group 'puppet)
-
-(defcustom puppet-include-indent 2
-  "*Indentation of continued Puppet include statements."
-  :type 'integer :group 'puppet)
-
-(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.")
-
-(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)
-    (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."
-  :type 'boolean :group 'puppet)
-
-(defcustom puppet-comment-column 32
-  "*Indentation column of comments."
-  :type 'integer :group 'puppet)
-
-(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
-    (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
-that array, else return nil."
-  (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-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-analyze-indent ()
-  "Analyze the identation at point and return the discovered indentation level
-we should use, or nil if we can't determine one."
-  (cond
-   ;; Comment lines are ignored unless we're at the start of the buffer.
-   ((puppet-comment-line-p)
-    (if (bobp) 0 nil))
-
-   ;; Closing 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-*$")
-    (current-indentation))
-
-   ;; Closing 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-*$")
-    (- (current-indentation) puppet-indent-level))
-
-   ;; Closing brace followed by a comma ends a selector within a resource and
-   ;; will be indented just the right amount.  Take similar precautions about
-   ;; blocks started and closed on the same line.
-   ((looking-at "^[^\n\({]*},\\s-*$")
-    (current-indentation))
-
-   ;; 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}]*$")
-    (+ (current-indentation) puppet-indent-level))
-
-   ;; Indent by one level if the line ends with an open paren.
-   ((looking-at "^.*(\\s-*$")
-    (+ (current-indentation) puppet-indent-level))
-
-   ;; 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-*$")
-    (- (current-indentation) puppet-indent-level))
-
-   ;; The line following the end of an array and a : should be indented one
-   ;; level more than the indentation of the start of the array.
-   ((looking-at "^.*\\]\\s-*:\\s-*$")
-      (let ((array-start (puppet-in-array)))
-        (if array-start
-          (save-excursion
-            (beginning-of-line)
-            (goto-char array-start)
-            (+ (current-indentation) puppet-indent-level))
-        (+ (current-indentation) puppet-indent-level))))
-
-   ;; Indent an extra level after : since it introduces a resource.
-   ((looking-at "^.*:\\s-*$")
-    (+ (current-indentation) puppet-indent-level))
-
-   ;; Start of buffer.
-   ((bobp)
-    0)))
-
-(defun puppet-do-indent ()
-  "Internal function for puppet-indent-line.  This does the indent without
-worrying about saving the excursion."
-  (beginning-of-line)
-  (if (bobp)
-      (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)
-
-      ;; First, check if we started in an array or on a block-ending line.
-      (cond
-       ;; This line probably starts with an element from an array.  Indent
-       ;; the line to the same indentation as the first element in that
-       ;; array.  That is, this...
-       ;;
-       ;;    exec { 'add puppetmaster mongrel startup links':
-       ;;      creates => [ 'string2', 'string3',
-       ;;      'string4', 'string5',
-       ;;      'string6', 'string7',
-       ;;      'string8' ],
-       ;;    }
-       ;;
-       ;; ...should instead look like this:
-       ;;
-       ;;    exec { 'add puppetmaster mongrel startup links':
-       ;;      creates => [ 'string2', 'string3',
-       ;;                   'string4', 'string5',
-       ;;                   'string6', 'string7',
-       ;;                   'string8' ],
-       ;;    }
-       (array-start
-        (save-excursion
-          (goto-char array-start)
-          (forward-char 1)
-          (if (looking-at "\\s-+\n")
-              (setq cur-indent (1+ (current-column)))
-            (re-search-forward "\\S-")
-            (forward-char -1)
-            (setq cur-indent (current-column)))))
-
-       ;; Inside an include.
-       (include-start
-        (setq cur-indent include-start))
-
-       ;; This line contains a closing brace, a closing brace followed by a
-       ;; comma, or a closing brace followed by else or elsif and we're at
-       ;; the inner block, so we should indent it matching the indentation
-       ;; of the opening brace of the block.
-       ((and (looking-at "^\\s-*}\\(,?\\s-*$\\|\\s-*els\\(e\\|if\\)\\s-\\)")
-             block-indent)
-        (setq cur-indent block-indent))
-
-       ;; Otherwise, we did not start on a block-ending-only line, so we
-       ;; have to search backwards for an indentation hint.
-       (t
-        (save-excursion
-          (while
-              (not (progn
-                     (forward-line -1)
-                     (setq cur-indent (puppet-analyze-indent))))))
-
-        ;; If this line contains only a closing paren or a closing paren
-        ;; followed by an opening brace, we added one too many levels of
-        ;; indentation and should lose one level.
-        (if (looking-at "^\\s-*)\\s-*\\({\\s-*\\)?$")
-            (setq cur-indent (- cur-indent puppet-indent-level)))))
-
-      ;; We've figured out the indentation, so do it.
-      (if (< cur-indent 0)
-          (indent-line-to 0)
-        (indent-line-to cur-indent)))))
-
-(defun puppet-indent-line ()
-  "Indent current line as Puppet code."
-  (interactive)
-  (if (or (bolp)
-          (save-excursion
-            (beginning-of-line)
-            (save-match-data (looking-at "\\s *\n"))))
-      (puppet-do-indent)
-    (save-excursion
-      (puppet-do-indent))))
-
-(defvar puppet-font-lock-syntax-table
-  (let* ((tbl (copy-syntax-table puppet-mode-syntax-table)))
-    (modify-syntax-entry ?_ "w" tbl)
-    tbl))
-
-;; Stupid hack required to allow me to assign a default face to something.
-;; WTF, font-lock mode?  Not required on XEmacs (and breaks XEmacs).
-(if (not (string-match "XEmacs" emacs-version))
-    (defvar puppet-font-lock-default-face 'default))
-
-(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)
-   ;; variables
-   '("\\$[a-zA-Z0-9_:]+" . font-lock-variable-name-face)
-   ;; usage of types
-   '("^\\s *\\([a-z][a-zA-Z0-9_:-]*\\)\\s +{"
-     1 font-lock-type-face)
-   ;; overrides, type references, and defaults
-   '("\\(\\s \\|[\\[]\\)\\([A-Z][a-zA-Z0-9_:-]*\\)\\s *[\\[{]"
-     2 font-lock-type-face)
-   ;; general delimited string
-   '("\\(^\\|[[ \t\n<+(,=]\\)\\(%[xrqQwW]?\\([^<[{(a-zA-Z0-9 \n]\\)[^\n\\\\]*\\(\\\\.[^\n\\\\]*\\)*\\(\\3\\)\\)"
-     2 font-lock-string-face)
-   ;; keywords
-   (cons (regexp-opt
-          '("alert"
-            "and"
-            "case"
-            "class"
-            "create_resources"
-            "crit"
-            "debug"
-            "default"
-            "define"
-            "defined"
-            "else"
-            "elsif"
-            "emerg"
-            "err"
-            "fail"
-            "false"
-            "file"
-            "filebucket"
-            "fqdn_rand"
-            "generate"
-            "if"
-            "import"
-            "in"
-            "include"
-            "info"
-            "inherits"
-            "inline_template"
-            "md5"
-            "node"
-            "not"
-            "notice"
-            "or"
-            "realize"
-            "regsubst"
-            "require"
-            "search"
-            "sha1"
-            "shellquote"
-            "split"
-            "sprintf"
-            "tag"
-            "tagged"
-            "template"
-            "true"
-            "undef"
-            "versioncmp"
-            "warning"
-            )
-          'words)
-         1)
-   ;; avoid marking require in resources as a keyword
-   '("\\b\\(require\\)\\s-*=>"
-     1 puppet-font-lock-default-face t))
-  "*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 'parse-sexp-ignore-comments) t)
-  (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-use-syntax) t)
-  (set (make-local-variable 'comment-end) "")
-  (set (make-local-variable 'comment-auto-fill-only-comments) t)
-  (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)
-
-;;; puppet-mode.el ends here

data/ext/vim/README

@@ -1,3 +0,0 @@
-To install these files, copy them into ~/.vim, or the relevant
-system-wide location.  To use the ftplugin and indenting, you may need
-to enable them with "filetype plugin indent on" in your vimrc.

data/ext/vim/ftdetect/puppet.vim

@@ -1,2 +0,0 @@
-" detect puppet filetype
-au BufRead,BufNewFile *.pp              set filetype=puppet

data/ext/vim/ftplugin/puppet.vim

@@ -1,94 +0,0 @@
-" Vim filetype plugin
-" Language:     Puppet
-" Maintainer:   Todd Zullinger <tmz@pobox.com>
-" Last Change:  2009 Aug 19
-" vim: set sw=4 sts=4:
-
-if exists("b:did_ftplugin")
-    finish
-endif
-let b:did_ftplugin = 1
-
-if !exists("no_plugin_maps") && !exists("no_puppet_maps")
-    if !hasmapto("<Plug>AlignRange")
-        map <buffer> <LocalLeader>= <Plug>AlignRange
-    endif
-endif
-
-noremap <buffer> <unique> <script> <Plug>AlignArrows :call <SID>AlignArrows()<CR>
-noremap <buffer> <unique> <script> <Plug>AlignRange :call <SID>AlignRange()<CR>
-
-iabbrev => =><C-R>=<SID>AlignArrows('=>')<CR>
-iabbrev +> +><C-R>=<SID>AlignArrows('+>')<CR>
-
-if exists('*s:AlignArrows')
-    finish
-endif
-
-let s:arrow_re = '[=+]>'
-let s:selector_re = '[=+]>\s*\$.*\s*?\s*{\s*$'
-
-function! s:AlignArrows(op)
-    let cursor_pos = getpos('.')
-    let lnum = line('.')
-    let line = getline(lnum)
-    if line !~ s:arrow_re
-        return
-    endif
-    let pos = stridx(line, a:op)
-    let start = lnum
-    let end = lnum
-    let pnum = lnum - 1
-    while 1
-        let pline = getline(pnum)
-        if pline !~ s:arrow_re || pline =~ s:selector_re
-            break
-        endif
-        let start = pnum
-        let pnum -= 1
-    endwhile
-    let cnum = end
-    while 1
-        let cline = getline(cnum)
-        if cline !~ s:arrow_re ||
-                \ (indent(cnum) != indent(cnum+1) && getline(cnum+1) !~ '\s*}')
-            break
-        endif
-        let end = cnum
-        let cnum += 1
-    endwhile
-    call s:AlignSection(start, end)
-    let cursor_pos[2] = stridx(getline('.'), a:op) + strlen(a:op) + 1
-    call setpos('.', cursor_pos)
-    return ''
-endfunction
-
-function! s:AlignRange() range
-    call s:AlignSection(a:firstline, a:lastline)
-endfunction
-
-" AlignSection and AlignLine are from the vim wiki:
-" http://vim.wikia.com/wiki/Regex-based_text_alignment
-function! s:AlignSection(start, end)
-    let extra = 1
-    let sep = s:arrow_re
-    let maxpos = 0
-    let section = getline(a:start, a:end)
-    for line in section
-        let pos = match(line, ' *'.sep)
-        if maxpos < pos
-            let maxpos = pos
-        endif
-    endfor
-    call map(section, 's:AlignLine(v:val, sep, maxpos, extra)')
-    call setline(a:start, section)
-endfunction
-
-function! s:AlignLine(line, sep, maxpos, extra)
-    let m = matchlist(a:line, '\(.\{-}\) \{-}\('.a:sep.'.*\)')
-    if empty(m)
-        return a:line
-    endif
-    let spaces = repeat(' ', a:maxpos - strlen(m[1]) + a:extra)
-    return m[1] . spaces . m[2]
-endfunction

data/ext/vim/indent/puppet.vim

@@ -1,76 +0,0 @@
-" Vim indent file
-" Language:	Puppet
-" Maintainer:	Todd Zullinger <tmz@pobox.com>
-" Last Change:	2009 Aug 19
-" vim: set sw=4 sts=4:
-
-if exists("b:did_indent")
-    finish
-endif
-let b:did_indent = 1
-
-setlocal autoindent smartindent
-setlocal indentexpr=GetPuppetIndent()
-setlocal indentkeys+=0],0)
-
-if exists("*GetPuppetIndent")
-    finish
-endif
-
-" Check if a line is part of an include 'block', e.g.:
-"   include foo,
-"       bar,
-"       baz
-function! s:PartOfInclude(lnum)
-    let lnum = a:lnum
-    while lnum
-        let lnum = lnum - 1
-        let line = getline(lnum)
-        if line !~ ',$'
-            break
-        endif
-        if line =~ '^\s*include\s\+[^,]\+,$'
-            return 1
-        endif
-    endwhile
-    return 0
-endfunction
-
-function! s:OpenBrace(lnum)
-    call cursor(a:lnum, 1)
-    return searchpair('{\|\[\|(', '', '}\|\]\|)', 'nbW')
-endfunction
-
-function! GetPuppetIndent()
-    let pnum = prevnonblank(v:lnum - 1)
-    if pnum == 0
-       return 0
-    endif
-
-    let line = getline(v:lnum)
-    let pline = getline(pnum)
-    let ind = indent(pnum)
-
-    if pline =~ '^\s*#'
-        return ind
-    endif
-
-    if pline =~ '\({\|\[\|(\|:\)$'
-        let ind += &sw
-    elseif pline =~ ';$' && pline !~ '[^:]\+:.*[=+]>.*'
-        let ind -= &sw
-    elseif pline =~ '^\s*include\s\+.*,$'
-        let ind += &sw
-    endif
-
-    if pline !~ ',$' && s:PartOfInclude(pnum)
-        let ind -= &sw
-    endif
-
-    " Match } }, }; ] ]: )
-    if line =~ '^\s*\(}\(,\|;\)\?$\|]:\?$\|)\)'
-        let ind = indent(s:OpenBrace(v:lnum))
-    endif
-
-    return ind
-endfunction