1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
# Grr
require 'puppet/parser/scope'
module Puppet::Parser
module Functions
# A module for managing parser functions. Each specified function
# becomes an instance method on the Scope class.
# Create a new function type.
def self.newfunction(name, ftype = :statement, &block)
@functions ||= {}
name = name.intern if name.is_a? String
if @functions.include? name
raise Puppet::DevError, "Function %s already defined" % name
end
# We want to use a separate, hidden module, because we don't want
# people to be able to call them directly.
unless defined? FCollection
eval("module FCollection; end")
end
unless ftype == :statement or ftype == :rvalue
raise Puppet::DevError, "Invalid statement type %s" % ftype.inspect
end
fname = "function_" + name.to_s
Puppet::Parser::Scope.send(:define_method, fname, &block)
# Someday we'll support specifying an arity, but for now, nope
#@functions[name] = {:arity => arity, :type => ftype}
@functions[name] = {:type => ftype, :name => fname}
end
# Determine if a given name is a function
def self.function(name)
name = name.intern if name.is_a? String
if @functions.include? name
return @functions[name][:name]
else
return false
end
end
# Determine if a given function returns a value or not.
def self.rvalue?(name)
name = name.intern if name.is_a? String
if @functions.include? name
case @functions[name][:type]
when :statement: return false
when :rvalue: return true
end
else
return false
end
end
# Include the specified classes
newfunction(:include) do |vals|
vals.each do |val|
if objecttype = lookuptype(val)
# It's a defined type, so set it into the scope so it can
# be evaluated.
setobject(
:type => val,
:arguments => {}
)
else
raise Puppet::ParseError, "Unknown class %s" % val
end
end
end
# Tag the current scope with each passed name
newfunction(:tag) do |vals|
vals.each do |val|
# Some hackery, because the tags are stored by object id
# for singletonness.
self.setclass(val.object_id, val)
end
# Also add them as tags
self.tag(*vals)
end
# Test whether a given tag is set. This functions as a big OR -- if any of the
# specified tags are unset, we return false.
newfunction(:tagged, :rvalue) do |vals|
classlist = self.classlist
retval = true
vals.each do |val|
unless classlist.include?(val) or self.tags.include?(val)
retval = false
break
end
end
return retval
end
# Test whether a given class or definition is defined
newfunction(:defined, :rvalue) do |vals|
retval = true
vals.each do |val|
unless builtintype?(val) or lookuptype(val)
retval = false
break
end
end
return retval
end
newfunction(:fail, :statement) do |vals|
vals = vals.collect { |s| s.to_s }.join(" ") if vals.is_a? Array
raise Puppet::ParseError, vals.to_s
end
end
end
# $Id$
|
