summaryrefslogtreecommitdiffstats
path: root/lib/puppet/parser/ast/leaf.rb
blob: 609bcd3cc864dfca90d5c8aaccc8ec90e15dac17 (plain)
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
class Puppet::Parser::AST
    # The base class for all of the leaves of the parse trees.  These
    # basically just have types and values.  Both of these parameters
    # are simple values, not AST objects.
    class Leaf < AST
        attr_accessor :value, :type

        # Return our value.
        def evaluate(hash)
            return @value
        end

        # Print the value in parse tree context.
        def tree(indent = 0)
            return ((@@indent * indent) + self.typewrap(self.value))
        end

        def to_s
            return @value
        end
    end

    # The boolean class.  True or false.  Converts the string it receives
    # to a Ruby boolean.
    class Boolean < AST::Leaf

        # Use the parent method, but then convert to a real boolean.
        def initialize(hash)
            super

            unless @value == 'true' or @value == 'false'
                raise Puppet::DevError,
                    "'%s' is not a boolean" % @value
            end
            if @value == 'true'
                @value = true
            else
                @value = false
            end
        end
    end

    # The base string class.
    class String < AST::Leaf
        # Interpolate the string looking for variables, and then return
        # the result.
        def evaluate(hash)
            return hash[:scope].strinterp(@value)
        end
    end

    # The base string class.
    class FlatString < AST::Leaf
        # Interpolate the string looking for variables, and then return
        # the result.
        def evaluate(hash)
            return @value
        end
    end

    # The 'default' option on case statements and selectors.
    class Default < AST::Leaf; end

    # Capitalized words; used mostly for type-defaults, but also
    # get returned by the lexer any other time an unquoted capitalized
    # word is found.
    class Type < AST::Leaf; end

    # Lower-case words.
    class Name < AST::Leaf; end

    # Host names, either fully qualified or just the short name
    class HostName < AST::Leaf
        def initialize(hash)
            super

            unless @value =~ %r{^[0-9a-zA-Z\-]+(\.[0-9a-zA-Z\-]+)*$}
                raise Puppet::DevError,
                    "'%s' is not a valid hostname" % @value
            end
        end
    end

    # A simple variable.  This object is only used during interpolation;
    # the VarDef class is used for assignment.
    class Variable < Name
        # Looks up the value of the object in the scope tree (does
        # not include syntactical constructs, like '$' and '{}').
        def evaluate(hash)
            begin
                return hash[:scope].lookupvar(@value)
            rescue Puppet::ParseError => except
                except.line = self.line
                except.file = self.file
                raise except
            rescue => detail
                error = Puppet::DevError.new(detail)
                error.line = self.line
                error.file = self.file
                error.backtrace = detail.backtrace
                raise error
            end
        end
    end

end