puppet 3.4.3 → 3.5.0.rc1

data/lib/puppet/parser/e4_parser_adapter.rb

@@ -0,0 +1,81 @@
+require 'puppet/pops'
+
+module Puppet; module Parser; end; end;
+# Adapts an egrammar/eparser to respond to the public API of the classic parser
+# and makes use of the new evaluator.
+#
+class Puppet::Parser::E4ParserAdapter
+
+  # Empty adapter fulfills watch_file contract without doing anything.
+  # @api private
+  class NullFileWatcher
+    def watch_file(file)
+      #nop
+    end
+  end
+
+  # @param file_watcher [#watch_file] something that can watch a file
+  def initialize(file_watcher = nil)
+    @file_watcher = file_watcher || NullFileWatcher.new
+    @file = ''
+    @string = ''
+    @use = :undefined
+    @@evaluating_parser ||= Puppet::Pops::Parser::EvaluatingParser::Transitional.new()
+  end
+
+  def file=(file)
+    @file = file
+    @use = :file
+    # watch if possible, but only if the file is something worth watching
+    @file_watcher.watch_file(file) if !file.nil? && file != ''
+  end
+
+  def parse(string = nil)
+    self.string= string if string
+
+    if @file =~ /\.rb$/ && @use != :string
+      # Will throw an error
+      parse_ruby_file
+    end
+
+    parse_result =
+    if @use == :string
+      # Parse with a source_file to set in created AST objects (it was either given, or it may be unknown
+      # if caller did not set a file and the present a string.
+      #
+      @@evaluating_parser.parse_string(@string, @file || "unknown-source-location")
+    else
+      @@evaluating_parser.parse_file(@file)
+    end
+
+    # the parse_result may be
+    # * empty / nil (no input)
+    # * a Model::Program
+    # * a Model::Expression
+    #
+    model = parse_result.nil? ? nil : parse_result.current 
+    args = {}
+    Puppet::Pops::Model::AstTransformer.new(@file).merge_location(args, model)
+
+    ast_code =
+    if model.is_a? Puppet::Pops::Model::Program
+      Puppet::Parser::AST::PopsBridge::Program.new(model, args)
+    else
+      args[:value] = model
+      Puppet::Parser::AST::PopsBridge::Expression.new(args)
+    end
+
+    # Create the "main" class for the content - this content will get merged with all other "main" content
+    Puppet::Parser::AST::Hostclass.new('', :code => ast_code)
+
+  end
+
+  def string=(string)
+    @string = string
+    @use = :string
+  end
+
+  def parse_ruby_file
+    raise Puppet::ParseError, "Ruby DSL is no longer supported. Attempt to parse #{@file}"
+  end
+end

data/lib/puppet/parser/e_parser_adapter.rb

@@ -36,7 +36,6 @@ class Puppet::Parser::EParserAdapter
 
       # Validate
       validate(parse_result)
-
       # Transform the result, but only if not nil
       parse_result = Puppet::Pops::Model::AstTransformer.new(source_file, @classic_parser).transform(parse_result) if parse_result
       if parse_result && !parse_result.is_a?(Puppet::Parser::AST::BlockExpression)

data/lib/puppet/parser/files.rb

@@ -15,7 +15,7 @@ module Puppet; module Parser; module Files
   def find_manifests_in_modules(pattern, environment)
     module_name, file_pattern = split_file_path(pattern)
     begin
-      if mod = Puppet::Module.find(module_name, environment)
+      if mod = environment.module(module_name)
         return [mod.name, mod.match_manifests(file_pattern)]
       end
     rescue Puppet::Module::InvalidName
@@ -31,7 +31,9 @@ module Puppet; module Parser; module Files
   # module.
   # In all cases, an absolute path is returned, which does not
   # necessarily refer to an existing file
-  def find_template(template, environment = nil)
+  #
+  # @api private
+  def find_template(template, environment)
     if template == File.expand_path(template)
       return template
     end
@@ -41,7 +43,7 @@ module Puppet; module Parser; module Files
       template_paths.collect { |path|
         File::join(path, template)
       }.each do |f|
-        return f if Puppet::FileSystem::File.exist?(f)
+        return f if Puppet::FileSystem.exist?(f)
       end
     end
 
@@ -53,7 +55,8 @@ module Puppet; module Parser; module Files
     nil
   end
 
-  def find_template_in_module(template, environment = nil)
+  # @api private
+  def find_template_in_module(template, environment)
     path, file = split_file_path(template)
 
     # Because templates don't have an assumed template name, like manifests do,
@@ -61,7 +64,7 @@ module Puppet; module Parser; module Files
     # directory.
     return nil unless file
 
-    if mod = Puppet::Module.find(path, environment) and t = mod.template(file)
+    if mod = environment.module(path) and t = mod.template(file)
       return t
     end
     nil
@@ -69,8 +72,9 @@ module Puppet; module Parser; module Files
 
   # Return an array of paths by splitting the +templatedir+ config
   # parameter.
-  def templatepath(environment = nil)
-    dirs = Puppet.settings.value(:templatedir, environment).split(File::PATH_SEPARATOR)
+  # @api private
+  def templatepath(environment)
+    dirs = Puppet.settings.value(:templatedir, environment.to_s).split(File::PATH_SEPARATOR)
     dirs.select do |p|
       File::directory?(p)
     end
@@ -78,6 +82,7 @@ module Puppet; module Parser; module Files
 
   # Split the path into the module and the rest of the path, or return
   # nil if the path is empty or absolute (starts with a /).
+  # @api private
   def split_file_path(path)
     if path == "" or Puppet::Util.absolute_path?(path)
       nil

data/lib/puppet/parser/functions.rb

@@ -22,7 +22,9 @@ module Puppet::Parser::Functions
 
     # Runs a newfunction to create a function for each of the log levels
     Puppet::Util::Log.levels.each do |level|
-      newfunction(level, :doc => "Log a message on the server at level #{level.to_s}.") do |vals|
+      newfunction(level,
+                  :environment => Puppet.lookup(:root_environment),
+                  :doc => "Log a message on the server at level #{level.to_s}.") do |vals|
         send(level, vals.join(" "))
       end
     end
@@ -41,11 +43,8 @@ module Puppet::Parser::Functions
   # environment
   #
   # @api private
-  def self.environment_module(env = nil)
-    if env and ! env.is_a?(Puppet::Node::Environment)
-      env = Puppet::Node::Environment.new(env)
-    end
-    @modules[ (env || Environment.current || Environment.root).name ] ||= Module.new
+  def self.environment_module(env)
+    @modules[env.name] ||= Module.new
   end
 
   # Create a new Puppet DSL function.
@@ -71,7 +70,8 @@ module Puppet::Parser::Functions
   #         :doc=>"Doubles an object, typically a number or string."}
   #
   # @example Invoke the double function from irb as is done in RSpec examples:
-  #     >> scope = Puppet::Parser::Scope.new_for_test_harness('example')
+  #     >> require 'puppet_spec/scope'
+  #     >> scope = PuppetSpec::Scope.create_test_scope_for_node('example')
   #     => Scope()
   #     >> scope.function_double([2])
   #     => 4
@@ -112,13 +112,18 @@ module Puppet::Parser::Functions
   #   zero or more arguments.  A function with an arity of 2 must be provided
   #   with exactly two arguments, no more and no less.  Added in Puppet 3.1.0.
   #
+  # @option options [Puppet::Node::Environment] :environment (nil) can
+  #   explicitly pass the environment we wanted the function added to.  Only used
+  #   to set logging functions in root environment
+  #
   # @return [Hash] describing the function.
   #
   # @api public
   def self.newfunction(name, options = {}, &block)
     name = name.intern
+    environment = options[:environment] || Puppet.lookup(:current_environment)
 
-    Puppet.warning "Overwriting previous definition for function #{name}" if get_function(name)
+    Puppet.warning "Overwriting previous definition for function #{name}" if get_function(name, environment)
 
     arity = options[:arity] || -1
     ftype = options[:type] || :statement
@@ -130,10 +135,10 @@ module Puppet::Parser::Functions
     # the block must be installed as a method because it may use "return",
     # which is not allowed from procs.
     real_fname = "real_function_#{name}"
-    environment_module.send(:define_method, real_fname, &block)
+    environment_module(environment).send(:define_method, real_fname, &block)
 
     fname = "function_#{name}"
-    environment_module.send(:define_method, fname) do |*args|
+    environment_module(environment).send(:define_method, fname) do |*args|
       Puppet::Util::Profiler.profile("Called #{name}") do
         if args[0].is_a? Array
           if arity >= 0 and args[0].size != arity
@@ -151,25 +156,26 @@ module Puppet::Parser::Functions
     func = {:arity => arity, :type => ftype, :name => fname}
     func[:doc] = options[:doc] if options[:doc]
 
-    add_function(name, func)
+    add_function(name, func, environment)
     func
   end
 
   # Determine if a function is defined
   #
   # @param [Symbol] name the function
+  # @param [Puppet::Node::Environment] environment the environment to find the function in
   #
   # @return [Symbol, false] The name of the function if it's defined,
   #   otherwise false.
   #
   # @api public
-  def self.function(name)
+  def self.function(name, environment = Puppet.lookup(:current_environment))
     name = name.intern
 
     func = nil
-    unless func = get_function(name)
-      autoloader.load(name, Environment.current)
-      func = get_function(name)
+    unless func = get_function(name, environment)
+      autoloader.load(name, environment)
+      func = get_function(name, environment)
     end
 
     if func
@@ -179,12 +185,12 @@ module Puppet::Parser::Functions
     end
   end
 
-  def self.functiondocs
+  def self.functiondocs(environment = Puppet.lookup(:current_environment))
     autoloader.loadall
 
     ret = ""
 
-    merged_functions.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, hash|
+    merged_functions(environment).sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, hash|
       ret << "#{name}\n#{"-" * name.to_s.length}\n"
       if hash[:doc]
         ret << Puppet::Util::Docs.scrub(hash[:doc])
@@ -201,42 +207,43 @@ module Puppet::Parser::Functions
   # Determine whether a given function returns a value.
   #
   # @param [Symbol] name the function
+  # @param [Puppet::Node::Environment] environment The environment to find the function in
+  # @return [Boolean] whether it is an rvalue function
   #
   # @api public
-  def self.rvalue?(name)
-    func = get_function(name)
+  def self.rvalue?(name, environment = Puppet.lookup(:current_environment))
+    func = get_function(name, environment)
     func ? func[:type] == :rvalue : false
   end
 
   # Return the number of arguments a function expects.
   #
   # @param [Symbol] name the function
+  # @param [Puppet::Node::Environment] environment The environment to find the function in
   # @return [Integer] The arity of the function. See {newfunction} for
   #   the meaning of negative values.
   #
   # @api public
-  def self.arity(name)
-    func = get_function(name)
+  def self.arity(name, environment = Puppet.lookup(:current_environment))
+    func = get_function(name, environment)
     func ? func[:arity] : -1
   end
 
   class << self
     private
 
-    def merged_functions
-      @functions[Environment.root].merge(@functions[Environment.current])
+    def merged_functions(environment)
+      @functions[Puppet.lookup(:root_environment)].merge(@functions[environment])
     end
 
-    def get_function(name)
+    def get_function(name, environment)
       name = name.intern
-      merged_functions[name]
+      merged_functions(environment)[name]
     end
 
-    def add_function(name, func)
+    def add_function(name, func, environment)
       name = name.intern
-      @functions[Environment.current][name] = func
+      @functions[environment][name] = func
     end
   end
-
-  reset  # initialize the class instance variables
 end

data/lib/puppet/parser/functions/collect.rb

@@ -12,4 +12,4 @@ Puppet::Parser::Functions::newfunction(
 
   raise NotImplementedError,
     "The 'collect' function has been renamed to 'map'. Please update your manifests."
-end
+end

data/lib/puppet/parser/functions/defined.rb

@@ -1,8 +1,11 @@
 # Test whether a given class or definition is defined
 Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :arity => -2, :doc => "Determine whether
   a given class or resource type is defined. This function can also determine whether a
-  specific resource has been declared. Returns true or false. Accepts class names,
-  type names, and resource references.
+  specific resource has been declared, or whether a variable has been assigned a value
+  (including undef...as opposed to never having been assigned anything). Returns true
+  or false. Accepts class names, type names, resource references, and variable
+  reference strings of the form '$name'.  When more than one argument is
+  supplied, defined() returns true if any are defined.
 
   The `defined` function checks both native and defined types, including types
   provided as plugins via modules. Types and classes are both checked using their names:
@@ -11,6 +14,7 @@ Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :arity => -2,
       defined(\"customtype\")
       defined(\"foo\")
       defined(\"foo::bar\")
+      defined(\'$name\')
 
   Resource declarations are checked using resource references, e.g.
   `defined( File['/tmp/myfile'] )`. Checking whether a given resource
@@ -18,32 +22,52 @@ Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :arity => -2,
   the configuration, and the following code will not work:
 
       if defined(File['/tmp/foo']) {
-          notify(\"This configuration includes the /tmp/foo file.\")
+          notify { \"This configuration includes the /tmp/foo file.\":}
       }
-      file {\"/tmp/foo\":
+      file { \"/tmp/foo\":
           ensure => present,
       }
 
   However, this order requirement refers to parse order only, and ordering of
   resources in the configuration graph (e.g. with `before` or `require`) does not
-  affect the behavior of `defined`.") do |vals|
-    result = false
+  affect the behavior of `defined`.
+
+  If the future parser is in effect, you may also search using types:
+
+      defined(Resource[\'file\',\'/some/file\'])
+      defined(File[\'/some/file\'])
+      defined(Class[\'foo\'])
+
+ - Since 2.7.0
+ - Since 3.6.0 variable reference and future parser types") do |vals|
     vals = [vals] unless vals.is_a?(Array)
-    vals.each do |val|
+    vals.any? do |val|
       case val
       when String
-        if Puppet::Type.type(val) or find_definition(val) or find_hostclass(val)
-          result = true
-          break
+        if m = /^\$(.+)$/.match(val)
+          exist?(m[1])
+        else
+          find_resource_type(val) or find_definition(val) or find_hostclass(val)
         end
       when Puppet::Resource
-        if findresource(val.to_s)
-          result = true
-          break
-        end
+        compiler.findresource(val.type, val.title)
       else
-        raise ArgumentError, "Invalid argument of type '#{val.class}' to 'defined'"
+        if Puppet[:parser] == 'future'
+          case val
+          when Puppet::Pops::Types::PResourceType
+            raise ArgumentError, "The given resource type is a reference to all kind of types" if val.type_name.nil?
+            if val.title.nil?
+              find_builtin_resource_type(val.type_name) || find_definition(val.type_name)
+            else
+              compiler.findresource(val.type_name, val.title)
+            end
+          when Puppet::Pops::Types::PHostClassType
+            raise  ArgumentError, "The given class type is a reference to all classes" if val.class_name.nil?
+            find_hostclass(val.class_name)
+          end
+        else
+          raise ArgumentError, "Invalid argument of type '#{val.class}' to 'defined'"
+        end
       end
     end
-    result
 end

data/lib/puppet/parser/functions/each.rb

@@ -6,17 +6,21 @@ Puppet::Parser::Functions::newfunction(
   Applies a parameterized block to each element in a sequence of selected entries from the first
   argument and returns the first argument.
 
-  This function takes two mandatory arguments: the first should be an Array or a Hash, and the second
+  This function takes two mandatory arguments: the first should be an Array or a Hash or something that is
+  of enumerable type (integer, Integer range, or String), and the second
   a parameterized block as produced by the puppet syntax:
 
         $a.each |$x| { ... }
+        each($a) |$x| { ... }
 
-  When the first argument is an Array, the parameterized block should define one or two block parameters.
+  When the first argument is an Array (or of enumerable type other than Hash), the parameterized block
+  should define one or two block parameters.
   For each application of the block, the next element from the array is selected, and it is passed to
   the block if the block has one parameter. If the block has two parameters, the first is the elements
   index, and the second the value. The index starts from 0.
 
         $a.each |$index, $value| { ... }
+        each($a) |$index, $value| { ... }
 
   When the first argument is a Hash, the parameterized block should define one or two parameters.
   When one parameter is defined, the iteration is performed with each entry as an array of `[key, value]`,
@@ -25,71 +29,81 @@ Puppet::Parser::Functions::newfunction(
         $a.each |$entry|       { ..."key ${$entry[0]}, value ${$entry[1]}" }
         $a.each |$key, $value| { ..."key ${key}, value ${value}" }
 
-  - Since 3.2
+  *Examples*
+
+        [1,2,3].each |$val| { ... }                       # 1, 2, 3
+        [5,6,7].each |$index, $val| { ... }               # (0, 5), (1, 6), (2, 7)
+        {a=>1, b=>2, c=>3}].each |$val| { ... }           # ['a', 1], ['b', 2], ['c', 3]
+        {a=>1, b=>2, c=>3}.each |$key, $val| { ... }      # ('a', 1), ('b', 2), ('c', 3)
+        Integer[ 10, 20 ].each |$index, $value| { ... }   # (0, 10), (1, 11) ...
+        "hello".each |$char| { ... }                      # 'h', 'e', 'l', 'l', 'o'
+        3.each |$number| { ... }                          # 0, 1, 2
+
+  - Since 3.2 for Array and Hash
+  - Since 3.5 for other enumerables
   - requires `parser = future`.
   ENDHEREDOC
   require 'puppet/parser/ast/lambda'
 
-  def foreach_Array(o, scope, pblock)
-    return nil unless pblock
-
-    serving_size = pblock.parameter_count
-    if serving_size == 0
-      raise ArgumentError, "Block must define at least one parameter; value."
-    end
-    if serving_size > 2
-      raise ArgumentError, "Block must define at most two parameters; index, value"
-    end
-    enumerator = o.each
-    index = 0
+  def foreach_Hash(o, scope, pblock, serving_size)
+    enumerator = o.each_pair
     if serving_size == 1
       (o.size).times do
         pblock.call(scope, enumerator.next)
       end
     else
       (o.size).times do
-        pblock.call(scope, index, enumerator.next)
-        index = index +1
+        pblock.call(scope, *enumerator.next)
       end
     end
-    o
   end
 
-  def foreach_Hash(o, scope, pblock)
-    return nil unless pblock
-    serving_size = pblock.parameter_count
-    case serving_size
-    when 0
-      raise ArgumentError, "Block must define at least one parameter (for hash entry key)."
-    when 1
-    when 2
-    else
-      raise ArgumentError, "Block must define at most two parameters (for hash entry key and value)."
-    end
-    enumerator = o.each_pair
+  def foreach_Enumerator(enumerator, scope, pblock, serving_size)
+    index = 0
     if serving_size == 1
-      (o.size).times do
-        pblock.call(scope, enumerator.next)
+      begin
+        loop { pblock.call(scope, enumerator.next) }
+      rescue StopIteration
       end
     else
-      (o.size).times do
-        pblock.call(scope, *enumerator.next)
+      begin
+        loop do
+          pblock.call(scope, index, enumerator.next)
+          index = index +1
+        end
+      rescue StopIteration
       end
     end
-    o
   end
 
-  raise ArgumentError, ("each(): wrong number of arguments (#{args.length}; must be 2)") if args.length != 2
+  raise ArgumentError, ("each(): wrong number of arguments (#{args.length}; expected 2, got #{args.length})") if args.length != 2
   receiver = args[0]
   pblock = args[1]
-  raise ArgumentError, ("each(): wrong argument type (#{args[1].class}; must be a parameterized block.") unless pblock.is_a? Puppet::Parser::AST::Lambda
+  raise ArgumentError, ("each(): wrong argument type (#{args[1].class}; must be a parameterized block.") unless pblock.respond_to?(:puppet_lambda)
+
+  serving_size = pblock.parameter_count
+  if serving_size == 0
+    raise ArgumentError, "each(): block must define at least one parameter; value. Block has 0."
+  end
 
   case receiver
-  when Array
-    foreach_Array(receiver, self, pblock)
   when Hash
-    foreach_Hash(receiver, self, pblock)
+    if serving_size > 2
+      raise ArgumentError, "each(): block must define at most two parameters; key, value. Block has #{serving_size}; "+
+      pblock.parameter_names.join(', ')
+    end
+    foreach_Hash(receiver, self, pblock, serving_size)
   else
-    raise ArgumentError, ("each(): wrong argument type (#{args[0].class}; must be an Array or a Hash.")
+    if serving_size > 2
+      raise ArgumentError, "each(): block must define at most two parameters; index, value. Block has #{serving_size}; "+
+        pblock.parameter_names.join(', ')
+    end
+    enum = Puppet::Pops::Types::Enumeration.enumerator(receiver)
+    unless enum
+      raise ArgumentError, ("each(): wrong argument type (#{receiver.class}; must be something enumerable.")
+    end
+    foreach_Enumerator(enum, self, pblock, serving_size)
   end
+  # each always produces the receiver
+  receiver
 end