Top Level Namespace

Includes:
Sys

Defined Under Namespace

Modules: DOT, DeepMerge, Enumerable, FFI, Generators, HieraPuppet, Kernel, Nagios, PSON, Puppet, PuppetX, RDoc, SemanticPuppet, StringBlank, Win32 Classes: CheckPuppet, Class, ExternalNode, Formatter, GitIgnoreSpec, Hash, Hiera, MyExternalNode, Object, PathSpec, RegexSpec, Spec, TestDeepMerge, TypeDoc, UserAttr, WindowsDaemon

Constant Summary collapse

SEPARATOR = 
[Regexp.escape(File::SEPARATOR.to_s), Regexp.escape(File::ALT_SEPARATOR.to_s)].join
Semantic = 
SemanticPuppet
BASEDIR = 
Dir.chdir(File.dirname(__FILE__) + "/..") { Dir.getwd }
WORKINGDIR = 
"#{p.realpath}"

Instance Method Summary collapse

Instance Method Details

#_(msg) ⇒ Object

These stub the translation methods noramlly brought in by FastGettext. Used when Gettext could not be properly initialized.



4
5
6
 
# File 'lib/puppet/gettext/stubs.rb', line 4

def _(msg)
  msg
end

#date ⇒ Object

lib/trollop.rb – trollop command-line processing library

Author

William Morgan (mailto: [email protected])

Copyright

Copyright 2007 William Morgan

License

the same terms as ruby itself

2012-03: small changes made by cprice ([email protected]);

patch submitted for upstream consideration:
https://gitorious.org/trollop/mainline/merge_requests/9

2012-08: namespace changes made by Jeff McCune ([email protected])

moved Trollop into Puppet::Util::CommandLine to prevent monkey
patching the upstream trollop library if also loaded.



13
 
# File 'lib/puppet/util/command_line/trollop.rb', line 13

require 'date'

#log(message, level = :debug) ⇒ Object

Helper method to log to syslog; we log at level debug if no level is specified since those are the most frequent calls to this method



65
66
67
 
# File 'ext/regexp_nodes/regexp_nodes.rb', line 65

def log(message,level=:debug)
  Syslog.send(level,message)
end

#n_(*args, &block) ⇒ Object 



8
9
10
11
 
# File 'lib/puppet/gettext/stubs.rb', line 8

def n_(*args, &block)
  plural = args[2] == 1 ? args[0] : args[1]
  block ? block.call : plural
end

#post_compile ⇒ Object

Since:

  • 3.4.0




# File 'lib/puppet/parameter.rb', line 556

#read_node(node) ⇒ Object

Read in a pure yaml representation of our node.



62
63
64
65
66
67
68
69
 
# File 'ext/yaml_nodes.rb', line 62

def read_node(node)
  nodefile = File.join(YAMLDIR, "#{node}.yaml")
  if FileTest.exist?(nodefile)
    return YAML.load_file(nodefile)
  else
    raise "Could not find information for #{node}"
  end
end

#regsubst ⇒ Array[String], String

Perform regexp replacement on a string or array of strings.

Examples:

Get the third octet from the node’s IP address:

$i3 = regsubst($ipaddress,'^(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)$','\\3')

Put angle brackets around each octet in the node’s IP address:

$x = regsubst($ipaddress, /([0-9]+)/, '<\\1>', 'G')



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/puppet/functions/regsubst.rb', line 35

Puppet::Functions.create_function(:regsubst) do
  dispatch :regsubst_string do
    param          'Variant[Array[String],String]',       :target
    param          'String',                              :pattern
    param          'Variant[String,Hash[String,String]]', :replacement
    optional_param 'Optional[Pattern[/^[GEIM]*$/]]',      :flags
    optional_param "Enum['N','E','S','U']",               :encoding
  end

  dispatch :regsubst_regexp do
    param          'Variant[Array[String],String]',       :target
    param          'Variant[Regexp,Type[Regexp]]',        :pattern
    param          'Variant[String,Hash[String,String]]', :replacement
    optional_param 'Pattern[/^G?$/]',                     :flags
  end

  def regsubst_string(target, pattern, replacement, flags = nil, encoding = nil)
    re_flags = 0
    operation = :sub
    if !flags.nil?
      flags.split(//).each do |f|
        case f
        when 'G' then operation = :gsub
        when 'E' then re_flags |= Regexp::EXTENDED
        when 'I' then re_flags |= Regexp::IGNORECASE
        when 'M' then re_flags |= Regexp::MULTILINE
        end
      end
    end
    inner_regsubst(target, Regexp.compile(pattern, re_flags, encoding), replacement, operation)
  end

  def regsubst_regexp(target, pattern, replacement, flags = nil)
    pattern = (pattern.pattern || '') if pattern.is_a?(Puppet::Pops::Types::PRegexpType)
    inner_regsubst(target, pattern, replacement, operation = flags == 'G' ? :gsub : :sub)
  end

  def inner_regsubst(target, re, replacement, op)
    target.respond_to?(op) ? target.send(op, re, replacement) : target.collect { |e| e.send(op, re, replacement) }
  end
  private :inner_regsubst
end