puppet 0.25.5 → 2.6.0

data/lib/puppet/parser/ast/ifstatement.rb

@@ -1,38 +1,34 @@
 require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
-    # A basic 'if/elsif/else' statement.
-    class IfStatement < AST::Branch
+  # A basic 'if/elsif/else' statement.
+  class IfStatement < AST::Branch
 
-        associates_doc
+    associates_doc
 
-        attr_accessor :test, :else, :statements
+    attr_accessor :test, :else, :statements
 
-        def each
-            [@test,@else,@statements].each { |child| yield child }
-        end
+    def each
+      [@test,@else,@statements].each { |child| yield child }
+    end
 
-        # Short-curcuit evaluation.  If we're true, evaluate our statements,
-        # else if there's an 'else' setting, evaluate it.
-        # the first option that matches.
-        def evaluate(scope)
-            level = scope.ephemeral_level
-            value = @test.safeevaluate(scope)
+    # Short-curcuit evaluation.  If we're true, evaluate our statements,
+    # else if there's an 'else' setting, evaluate it.
+    # the first option that matches.
+    def evaluate(scope)
+      level = scope.ephemeral_level
+      value = @test.safeevaluate(scope)
 
-            # let's emulate a new scope for each branches
-            begin
-                if Puppet::Parser::Scope.true?(value)
-                    return @statements.safeevaluate(scope)
-                else
-                    if defined? @else
-                        return @else.safeevaluate(scope)
-                    else
-                        return nil
-                    end
-                end
-            ensure
-                scope.unset_ephemeral_var(level)
-            end
+      # let's emulate a new scope for each branches
+      begin
+        if Puppet::Parser::Scope.true?(value)
+          return @statements.safeevaluate(scope)
+        else
+          return defined?(@else) ? @else.safeevaluate(scope) : nil
         end
+      ensure
+        scope.unset_ephemeral_var(level)
+      end
     end
+  end
 end

data/lib/puppet/parser/ast/in_operator.rb

@@ -0,0 +1,24 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  class InOperator < AST::Branch
+
+    attr_accessor :lval, :rval
+
+    # Returns a boolean which is the result of the 'in' operation
+    # of lval and rval operands
+    def evaluate(scope)
+
+      # evaluate the operands, should return a boolean value
+      lval = @lval.safeevaluate(scope)
+      raise ArgumentError, "'#{lval}' from left operand of 'in' expression is not a string" unless lval.is_a?(::String)
+
+      rval = @rval.safeevaluate(scope)
+      unless rval.respond_to?(:include?)
+        raise ArgumentError, "'#{rval}' from right operand of 'in' expression is not of a supported type (string, array or hash)"
+      end
+      rval.include?(lval)
+    end
+  end
+end

data/lib/puppet/parser/ast/leaf.rb

@@ -1,196 +1,213 @@
 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(scope)
-            return @value
-        end
-
-        # evaluate ourselves, and match
-        def evaluate_match(value, scope, options = {})
-            obj = self.safeevaluate(scope)
-            if ! options[:sensitive] && obj.respond_to?(:downcase)
-                obj = obj.downcase
-            end
-            value = value.downcase if not options[:sensitive] and value.respond_to?(:downcase)
-            obj == value
-        end
+  # 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(scope)
+      @value
+    end
 
-        def match(value)
-            @value == value
-        end
+    def match(value)
+      @value == value
+    end
 
-        def to_s
-            return @value.to_s unless @value.nil?
-        end
+    def to_s
+      @value.to_s unless @value.nil?
     end
+  end
 
-    # The boolean class.  True or false.  Converts the string it receives
-    # to a Ruby boolean.
-    class Boolean < AST::Leaf
+  # 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
+    # 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
-            @value
-        end
+      unless @value == true or @value == false
+        raise Puppet::DevError,
+          "'#{@value}' is not a boolean"
+      end
+      @value
+    end
 
-        def to_s
-            @value ? "true" : "false"
-        end
+    def to_s
+      @value ? "true" : "false"
     end
+  end
 
-    # The base string class.
-    class String < AST::Leaf
-        # Interpolate the string looking for variables, and then return
-        # the result.
-        def evaluate(scope)
-            return scope.strinterp(@value, file, line)
-        end
+  # The base string class.
+  class String < AST::Leaf
+    def evaluate(scope)
+      @value
+    end
 
-        def to_s
-            "\"#{@value}\""
-        end
+    def to_s
+      "\"#{@value}\""
     end
+  end
 
-    # An uninterpreted string.
-    class FlatString < AST::Leaf
-        def evaluate(scope)
-            return @value
-        end
+  # An uninterpreted string.
+  class FlatString < AST::Leaf
+    def evaluate(scope)
+      @value
+    end
 
-        def to_s
-            "\"#{@value}\""
-        end
+    def to_s
+      "\"#{@value}\""
     end
+  end
 
-    # The 'default' option on case statements and selectors.
-    class Default < AST::Leaf; end
+  class Concat < AST::Leaf
+    def evaluate(scope)
+      @value.collect { |x| x.evaluate(scope) }.collect{ |x| x == :undef ? '' : x }.join
+    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
+    def to_s
+      "concat(#{@value.join(',')})"
+    end
+  end
 
-    # Lower-case words.
-    class Name < AST::Leaf; end
+  # The 'default' option on case statements and selectors.
+  class Default < AST::Leaf; end
 
-    # double-colon separated class names
-    class ClassName < 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
 
-    # undef values; equiv to nil
-    class Undef < AST::Leaf; end
+  # Lower-case words.
+  class Name < AST::Leaf; end
 
-    # Host names, either fully qualified or just the short name, or even a regex
-    class HostName < AST::Leaf
-        def initialize(hash)
-            super
+  # double-colon separated class names
+  class ClassName < AST::Leaf; end
 
-            @value = @value.to_s.downcase unless @value.is_a?(Regex)
-            if @value =~ /[^-\w.]/
-                raise Puppet::DevError,
-                    "'%s' is not a valid hostname" % @value
-            end
-        end
+  # undef values; equiv to nil
+  class Undef < AST::Leaf; end
 
-        def to_classname(dummy_argument=:work_arround_for_ruby_GC_bug)
-            to_s.downcase.gsub(/[^-\w:.]/,'').sub(/^\.+/,'')
-        end
+  # Host names, either fully qualified or just the short name, or even a regex
+  class HostName < AST::Leaf
+    def initialize(hash)
+      super
 
-        # implementing eql? and hash so that when an HostName is stored
-        # in a hash it has the same hashing properties as the underlying value
-        def eql?(value)
-            value = value.value if value.is_a?(HostName)
-            return @value.eql?(value)
-        end
+      # Note that this is an AST::Regex, not a Regexp
+      @value = @value.to_s.downcase unless @value.is_a?(Regex)
+      if @value =~ /[^-\w.]/
+        raise Puppet::DevError,
+          "'#{@value}' is not a valid hostname"
+      end
+    end
 
-        def hash
-            return @value.hash
-        end
+    # implementing eql? and hash so that when an HostName is stored
+    # in a hash it has the same hashing properties as the underlying value
+    def eql?(value)
+      value = value.value if value.is_a?(HostName)
+      @value.eql?(value)
+    end
 
-        def match(value)
-            return @value.match(value) unless value.is_a?(HostName)
-
-            if value.regex? and self.regex?
-                # Wow this is some sweet design; maybe a touch of refactoring
-                # in order here.
-                return value.value.value == self.value.value
-            elsif value.regex? # we know if the existing name is not a regex, it won't match a regex
-                return false
-            else
-                # else, we could be either a regex or normal and it doesn't matter
-                return @value.match(value.value)
-            end
-        end
+    def hash
+      @value.hash
+    end
 
-        def regex?
-            @value.is_a?(Regex)
-        end
+    def to_s
+      @value.to_s
+    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(scope)
+      parsewrap do
+        if (var = scope.lookupvar(@value, false)) == :undefined
+          var = :undef
+        end
+        var
+      end
+    end
 
-        def to_s
-            @value.to_s
-        end
+    def to_s
+      "\$#{value}"
     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(scope)
-            parsewrap do
-                return scope.lookupvar(@value)
-            end
-        end
+  class HashOrArrayAccess < AST::Leaf
+    attr_accessor :variable, :key
 
-        def to_s
-            "\$#{value}"
-        end
+    def evaluate_container(scope)
+      container = variable.respond_to?(:evaluate) ? variable.safeevaluate(scope) : variable
+      (container.is_a?(Hash) or container.is_a?(Array)) ? container : scope.lookupvar(container)
     end
 
-    class Regex < AST::Leaf
-        def initialize(hash)
-            super
-            @value = Regexp.new(@value) unless @value.is_a?(Regexp)
-        end
+    def evaluate_key(scope)
+      key.respond_to?(:evaluate) ? key.safeevaluate(scope) : key
+    end
 
-        # we're returning self here to wrap the regexp and to be used in places
-        # where a string would have been used, without modifying any client code.
-        # For instance, in many places we have the following code snippet:
-        #  val = @val.safeevaluate(@scope)
-        #  if val.match(otherval)
-        #      ...
-        #  end
-        # this way, we don't have to modify this test specifically for handling
-        # regexes.
-        def evaluate(scope)
-            return self
-        end
+    def evaluate(scope)
+      object = evaluate_container(scope)
 
-        def evaluate_match(value, scope, options = {})
-            value = value.is_a?(String) ? value : value.to_s
+      raise Puppet::ParseError, "#{variable} is not an hash or array when accessing it with #{accesskey}" unless object.is_a?(Hash) or object.is_a?(Array)
 
-            if matched = @value.match(value)
-                scope.ephemeral_from(matched, options[:file], options[:line])
-            end
-            matched
-        end
+      object[evaluate_key(scope)]
+    end
 
-        def match(value)
-            @value.match(value)
-        end
+    # Assign value to this hashkey or array index
+    def assign(scope, value)
+      object = evaluate_container(scope)
+      accesskey = evaluate_key(scope)
 
-        def to_s
-            return "/#{@value.source}/"
-        end
+      if object.is_a?(Hash) and object.include?(accesskey)
+        raise Puppet::ParseError, "Assigning to the hash '#{variable}' with an existing key '#{accesskey}' is forbidden"
+      end
+
+      # assign to hash or array
+      object[accesskey] = value
+    end
+
+    def to_s
+      "\$#{variable.to_s}[#{key.to_s}]"
+    end
+  end
+
+  class Regex < AST::Leaf
+    def initialize(hash)
+      super
+      @value = Regexp.new(@value) unless @value.is_a?(Regexp)
+    end
+
+    # we're returning self here to wrap the regexp and to be used in places
+    # where a string would have been used, without modifying any client code.
+    # For instance, in many places we have the following code snippet:
+    #  val = @val.safeevaluate(@scope)
+    #  if val.match(otherval)
+    #      ...
+    #  end
+    # this way, we don't have to modify this test specifically for handling
+    # regexes.
+    def evaluate(scope)
+      self
+    end
+
+    def evaluate_match(value, scope, options = {})
+      value = value.is_a?(String) ? value : value.to_s
+
+      if matched = @value.match(value)
+        scope.ephemeral_from(matched, options[:file], options[:line])
+      end
+      matched
+    end
+
+    def match(value)
+      @value.match(value)
+    end
+
+    def to_s
+      "/#{@value.source}/"
     end
+  end
 end