puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

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

@@ -34,9 +34,7 @@ Example Using map with two arguments
      # Turns hash into array of keys
      $a.map |$key,$val|{ $key }
 
-- since 3.4 for Array and Hash
-- since 3.5 for other enumerables, and support for blocks with 2 parameters
-- note requires `parser = future`
+- Since 4.0.0
 DOC
 ) do |args|
   function_fail(["map() is only available when parser/evaluator future is in effect"])

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

@@ -20,8 +20,7 @@ Example matching:
 
 See the documentation for "The Puppet Type System" for more information about types.
 
-- since 3.7.0
-- note requires future parser
+- Since 4.0.0
 DOC
 ) do |args|
   function_fail(["match() is only available when parser/evaluator future is in effect"])

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

@@ -8,12 +8,7 @@ Puppet::Parser::Functions::newfunction(:realize, :arity => -2, :doc => "Make a v
     reference; e.g.: `realize User[luke]`." ) do |vals|
 
     vals = [vals] unless vals.is_a?(Array)
-    if Puppet.future_parser?
-      coll = Puppet::Pops::Evaluator::Collectors::FixedSetCollector.new(self, vals.flatten)
-    else
-      coll = Puppet::Parser::Collector.new(self, :nomatter, nil, nil, :virtual)
-      coll.resources = vals.flatten
-    end
 
+    coll = Puppet::Pops::Evaluator::Collectors::FixedSetCollector.new(self, vals.flatten)
     compiler.add_collection(coll)
 end

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

@@ -62,9 +62,7 @@ Example Using reduce with an Integer range
       Integer[1,4].reduce |$memo, $x| { $memo + $x }
       #=> 10
 
-- since 3.2 for Array and Hash
-- since 3.5 for additional enumerable types
-- note requires `parser = future`.
+- since 4.0.0
 DOC
 ) do |args|
   function_fail(["reduce() is only available when parser/evaluator future is in effect"])

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

@@ -56,61 +56,5 @@ Put angle brackets around each octet in the node's IP address:
 
     $x = regsubst($ipaddress, '([0-9]+)', '<\\1>', 'G')
 ") do |args|
-  unless args.length.between?(3, 5)
-
-    raise(
-      ArgumentError,
-
-        "regsubst(): got #{args.length} arguments, expected 3 to 5")
-  end
-  target, regexp, replacement, flags, lang = args
-  reflags = 0
-  operation = :sub
-  if flags == nil
-    flags = []
-  elsif flags.respond_to?(:split)
-    flags = flags.split('')
-  else
-
-    raise(
-      Puppet::ParseError,
-
-        "regsubst(): bad flags parameter #{flags.class}:`#{flags}'")
-  end
-  flags.each do |f|
-    case f
-    when 'G' then operation = :gsub
-    when 'E' then reflags |= Regexp::EXTENDED
-    when 'I' then reflags |= Regexp::IGNORECASE
-    when 'M' then reflags |= Regexp::MULTILINE
-    else raise(Puppet::ParseError, "regsubst(): bad flag `#{f}'")
-    end
-  end
-  begin
-    re = Regexp.compile(regexp, reflags, lang)
-  rescue RegexpError, TypeError
-
-    raise(
-      Puppet::ParseError,
-
-        "regsubst(): Bad regular expression `#{regexp}'")
-  end
-  if target.respond_to?(operation)
-    # String parameter -> string result
-    result = target.send(operation, re, replacement)
-  elsif target.respond_to?(:collect) and
-    target.respond_to?(:all?) and
-    target.all? { |e| e.respond_to?(operation) }
-    # Array parameter -> array result
-    result = target.collect { |e|
-      e.send(operation, re, replacement)
-    }
-  else
-
-    raise(
-      Puppet::ParseError,
-
-        "regsubst(): bad target #{target.class}:`#{target}'")
-  end
-  return result
+    function_fail(['regsubst() has been converted to 4x API'])
 end

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

@@ -27,10 +27,12 @@ For instance the following manifest, with 'require' instead of 'include' would p
 Note that this function only works with clients 0.25 and later, and it will
 fail if used with earlier clients.
 
-When the future parser is used, you must use the class's full name;
-relative names are no longer allowed. In addition to names in string form,
-you may also directly use Class and Resource Type values that are produced by
-the future parser's resource and relationship expressions.
+You must use the class's full name;
+relative names are not allowed. In addition to names in string form,
+you may also directly use Class and Resource Type values that are produced when evaluating
+resource and relationship expressions.
+
+- Since 4.0.0 Class and Resource types, absolute names
 ") do |vals|
   # Make call patterns uniform and protected against nested arrays, also make
   # names absolute if so desired.

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

@@ -18,7 +18,7 @@ there was no succesful scan at all, the result is an empty Array.
       scanf("42", "%i")[0] == 42
 
 
-When used with the future parser, an optional parameterized block may be given.  
+When used with the future parser, an optional parameterized block may be given.
 The block is called with the result that is produced by scanf if no block is
 present, the result of the block is then returned by the function.
 

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

@@ -39,9 +39,7 @@ Example Using slice without a block
     slice(4,2)              # produces [[0,1], [2,3]]
     slice('hello',2)        # produces [[h, e], [l, l], [o]]
 
-- since 3.2 for Array and Hash
-- since 3.5 for additional enumerable types
-- note requires `parser = future`.
+- Since 4.0.0
 DOC
 ) do |args|
   function_fail(["slice() is only available when parser/evaluator future is in effect"])

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

@@ -23,6 +23,6 @@ a regexp meta-character (.), which must be escaped.  A simple
 way to do that for a single character is to enclose it in square
 brackets; a backslash will also escape a single character.") do |args|
 
-  return args[0].split(Regexp.compile(args[1]))
+    function_fail(['split() has been converted to 4x API'])
   end
 end

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

@@ -13,8 +13,7 @@ Example:
      # notices the array [1, 2, 'foo']
      with(1, 2, 'foo') |$x, $y, $z| { notice [$x, $y, $z] }
 
-- since 3.7.0
-- note requires future parser
+- since 4.0.0
 DOC
 ) do |args|
   function_fail(["with() is only available when parser/evaluator future is in effect"])

data/lib/puppet/parser/parser_factory.rb

@@ -8,33 +8,21 @@ module Puppet::Parser
   #
   class ParserFactory
     # Produces a parser instance for the given environment
-    def self.parser(environment)
-      if Puppet.future_parser?
-        evaluating_parser(environment)
-      else
-        classic_parser(environment)
-      end
-    end
-
-    # Creates an instance of the classic parser.
-    #
-    def self.classic_parser(environment)
-      # avoid expensive require if already loaded
-      require 'puppet/parser' unless defined? Puppet::Parser::Parser
-      Puppet::Parser::Parser.new(environment)
+    def self.parser
+      evaluating_parser
     end
 
     # Creates an instance of an E4ParserAdapter that adapts an
     # EvaluatingParser to the 3x way of parsing.
     #
-    def self.evaluating_parser(file_watcher)
+    def self.evaluating_parser
       # Since RGen is optional, test that it is installed
       assert_rgen_installed()
       unless defined?(Puppet::Pops::Parser::E4ParserAdapter)
         require 'puppet/parser/e4_parser_adapter'
         require 'puppet/pops/parser/code_merger'
       end
-      E4ParserAdapter.new(file_watcher)
+      E4ParserAdapter.new
     end
 
     # Asserts that RGen >= 0.6.6 is installed by checking that certain behavior is available.
@@ -66,11 +54,7 @@ module Puppet::Parser
     end
 
     def self.code_merger
-      if Puppet.future_parser?
-        Puppet::Pops::Parser::CodeMerger.new
-      else
-        Puppet::Parser::CodeMerger.new
-      end
+      Puppet::Pops::Parser::CodeMerger.new
     end
   end
 end

data/lib/puppet/parser/relationship.rb

@@ -4,28 +4,13 @@ class Puppet::Parser::Relationship
   PARAM_MAP = {:relationship => :before, :subscription => :notify}
 
   def arrayify(resources)
-    # This if statement is needed because the 3x parser cannot load
-    # Puppet::Pops. This logic can be removed for 4.0 when the 3x AST
-    # is removed (when Pops is always used).
-    if !(Puppet.future_parser?)
-      case resources
-      when Puppet::Parser::Collector
-        resources.collected.values
-      when Array
-        resources
-      else
-        [resources]
-      end
+    case resources
+    when Puppet::Pops::Evaluator::Collectors::AbstractCollector
+      resources.collected.values
+    when Array
+      resources
     else
-      require 'puppet/pops'
-      case resources
-      when Puppet::Pops::Evaluator::Collectors::AbstractCollector
-        resources.collected.values
-      when Array
-        resources
-      else
-        [resources]
-      end
+      [resources]
     end
   end
 
@@ -46,21 +31,13 @@ class Puppet::Parser::Relationship
   end
 
   def mk_relationship(source, target, catalog)
-    # REVISIT: In Ruby 1.8 we applied `to_s` to source and target, rather than
-    # `join` without an argument.  In 1.9 the behaviour of Array#to_s changed,
-    # and it gives a different representation than just concat the stringified
-    # elements.
-    #
-    # This restores the behaviour, but doesn't address the underlying question
-    # of what would happen when more than one item was passed in that array.
-    # (Hint: this will not end well.)
-    #
-    # See http://projects.puppetlabs.com/issues/12076 for the ticket tracking
-    # the fact that we should dig out the sane version of this behaviour, then
-    # implement it - where we don't risk breaking a stable release series.
-    # --daniel 2012-01-21
-    source = source.is_a?(Array) ? source.join : source.to_s
-    target = target.is_a?(Array) ? target.join : target.to_s
+    # There was once an assumption that this could be an array. These raise
+    # assertions are here as a sanity check for 4.0 and can be removed after
+    # a release or two
+    raise ArgumentError, "source shouldn't be an array" if source.is_a?(Array)
+    raise ArgumentError, "target shouldn't be an array" if target.is_a?(Array)
+    source = source.to_s
+    target = target.to_s
 
     unless source_resource = catalog.resource(source)
       raise ArgumentError, "Could not find resource '#{source}' for relationship on '#{target}'"
@@ -68,7 +45,7 @@ class Puppet::Parser::Relationship
     unless catalog.resource(target)
       raise ArgumentError, "Could not find resource '#{target}' for relationship from '#{source}'"
     end
-    Puppet.debug "Adding relationship from #{source} to #{target} with '#{param_name}'"
+    Puppet.debug {"Adding relationship from #{source} to #{target} with '#{param_name}'"}
     if source_resource[param_name].class != Array
       source_resource[param_name] = [source_resource[param_name]].compact
     end

data/lib/puppet/parser/resource.rb

@@ -73,19 +73,16 @@ class Puppet::Parser::Resource < Puppet::Resource
   # Retrieve the associated definition and evaluate it.
   def evaluate
     return if evaluated?
-
-    Puppet::Util::Profiler.profile("Evaluated resource #{self}", [:compiler, :evaluate_resource, self]) do
-      @evaluated = true
-      if klass = resource_type and ! builtin_type?
-        finish
-        evaluated_code = klass.evaluate_code(self)
-
-        return evaluated_code
-      elsif builtin?
-        devfail "Cannot evaluate a builtin type (#{type})"
-      else
-        self.fail "Cannot find definition #{type}"
-      end
+    @evaluated = true
+    if klass = resource_type and ! builtin_type?
+      finish
+      evaluated_code = klass.evaluate_code(self)
+
+      return evaluated_code
+    elsif builtin?
+      devfail "Cannot evaluate a builtin type (#{type})"
+    else
+      self.fail "Cannot find definition #{type}"
     end
   end
 
@@ -146,14 +143,6 @@ class Puppet::Parser::Resource < Puppet::Resource
     end
   end
 
-  # This only mattered for clients < 0.25, which we don't support any longer.
-  # ...but, since this hasn't been deprecated, and at least some functions
-  # used it, deprecate now rather than just eliminate. --daniel 2012-07-15
-  def metaparam_compatibility_mode?
-    Puppet.deprecation_warning "metaparam_compatibility_mode? is obsolete since < 0.25 clients are really, really not supported any more"
-    false
-  end
-
   def name
     self[:name] || self.title
   end
@@ -225,7 +214,7 @@ class Puppet::Parser::Resource < Puppet::Resource
 
   def add_scope_tags
     if scope_resource = scope.resource
-      tag(*scope_resource.tags)
+      merge_tags(scope_resource)
     end
   end
 

data/lib/puppet/parser/scope.rb

@@ -1,3 +1,4 @@
+
 # The scope class, which handles storing and retrieving variables and types and
 # such.
 require 'forwardable'
@@ -247,22 +248,12 @@ class Puppet::Parser::Scope
     end
   end
 
-  # Add to our list of namespaces.
-  def add_namespace(ns)
-    return false if @namespaces.include?(ns)
-    if @namespaces == [""]
-      @namespaces = [ns]
-    else
-      @namespaces << ns
-    end
-  end
-
-  def find_hostclass(name, options = {})
-    known_resource_types.find_hostclass(namespaces, name, options)
+  def find_hostclass(name)
+    known_resource_types.find_hostclass(name)
   end
 
   def find_definition(name)
-    known_resource_types.find_definition(namespaces, name)
+    known_resource_types.find_definition(name)
   end
 
   def find_global_scope()
@@ -293,9 +284,9 @@ class Puppet::Parser::Scope
     end
 
     if n = options.delete(:namespace)
-      @namespaces = [n]
+      @namespaces = [n.freeze].freeze
     else
-      @namespaces = [""]
+      @namespaces = ["".freeze].freeze
     end
 
     raise Puppet::DevError, "compiler passed in options" if options.include? :compiler
@@ -319,8 +310,6 @@ class Puppet::Parser::Scope
     # The table for storing class singletons.  This will only actually
     # be used by top scopes and node scopes.
     @class_scopes = {}
-
-    @enable_immutable_data = Puppet[:immutable_node_data]
   end
 
   # Store the fact that we've evaluated a class, and store a reference to
@@ -377,7 +366,8 @@ class Puppet::Parser::Scope
 
   # Look up a defined type.
   def lookuptype(name)
-    find_definition(name) || find_hostclass(name)
+    # This happens a lot, avoid making a call to make a call
+    known_resource_types.find_definition(name) || known_resource_types.find_hostclass(name)
   end
 
   def undef_as(x,v)
@@ -428,12 +418,7 @@ class Puppet::Parser::Scope
       return nil
     end
     if Puppet[:strict_variables]
-      if Puppet.future_parser?
-        throw :undefined_variable
-      else
-        reason_msg = reason.nil? ? '' : "; #{reason}"
-        raise Puppet::ParseError, "Undefined variable #{name.inspect}#{reason_msg}"
-      end
+      throw :undefined_variable
     else
       nil
     end
@@ -499,36 +484,24 @@ class Puppet::Parser::Scope
   def lookup_qualified_variable(class_name, variable_name, position)
     begin
       if lookup_as_local_name?(class_name, variable_name)
-        if is_topscope?
-          # This is the case where $::x is looked up from within the topscope itself, or from a local scope
-          # parented at the top scope. In this case, the lookup must ignore local and ephemeral scopes.
-          #
-          handle_not_found(class_name, variable_name, position) unless @symtable.include?(variable_name)
-          @symtable[variable_name]
-        else
-          self[variable_name]
-        end
+        self[variable_name]
       else
         qualified_scope(class_name).lookupvar(variable_name, position)
       end
     rescue RuntimeError => e
-      handle_not_found(class_name, variable_name, position, e.message)
-    end
-  end
-
-  def handle_not_found(class_name, variable_name, position, reason = nil)
-    unless Puppet[:strict_variables]
-      # Do not issue warning if strict variables are on, as an error will be raised by variable_not_found
-      location = if position[:lineproc]
-                   " at #{position[:lineproc].call}"
-                 elsif position[:file] && position[:line]
-                   " at #{position[:file]}:#{position[:line]}"
-                 else
-                   ""
-                 end
-      warning "Could not look up qualified variable '#{class_name}::#{variable_name}'; #{reason}#{location}"
+      unless Puppet[:strict_variables]
+        # Do not issue warning if strict variables are on, as an error will be raised by variable_not_found
+        location = if position[:lineproc]
+                     " at #{position[:lineproc].call}"
+                   elsif position[:file] && position[:line]
+                     " at #{position[:file]}:#{position[:line]}"
+                   else
+                     ""
+                   end
+        warning "Could not look up qualified variable '#{class_name}::#{variable_name}'; #{e.message}#{location}"
+      end
+      variable_not_found("#{class_name}::#{variable_name}", e.message)
     end
-    variable_not_found("#{class_name}::#{variable_name}", reason)
   end
 
   # Handles the special case of looking up fully qualified variable in not yet evaluated top scope
@@ -567,29 +540,11 @@ class Puppet::Parser::Scope
   # by default) including the values defined in parent. Local values
   # shadow parent values. Ephemeral scopes for match results ($0 - $n) are not included.
   #
-  # This is currently a wrapper for to_hash_legacy or to_hash_future.
-  #
-  # @see to_hash_future
-  #
-  # @see to_hash_legacy
   def to_hash(recursive = true)
-    @future_parser ||= Puppet.future_parser?
-    if @future_parser
-      to_hash_future(recursive)
-    else
-      to_hash_legacy(recursive)
-    end
-  end
-
-  # Fixed version of to_hash that implements scoping correctly (i.e., with
-  # dynamic scoping disabled #28200 / PUP-1220
-  #
-  # @see to_hash
-  def to_hash_future(recursive)
     if recursive and has_enclosing_scope?
-      target = enclosing_scope.to_hash_future(recursive)
+      target = enclosing_scope.to_hash(recursive)
       if !(inherited = inherited_scope).nil?
-        target.merge!(inherited.to_hash_future(recursive))
+        target.merge!(inherited.to_hash(recursive))
       end
     else
       target = Hash.new
@@ -600,24 +555,8 @@ class Puppet::Parser::Scope
     target
   end
 
-  # The old broken implementation of to_hash that retains the dynamic scoping
-  # semantics
-  #
-  # @see to_hash
-  def to_hash_legacy(recursive = true)
-    if recursive and parent
-      target = parent.to_hash_legacy(recursive)
-    else
-      target = Hash.new
-    end
-
-    # add all local scopes
-    @ephemeral.last.add_entries_to(target)
-    target
-  end
-
   def namespaces
-    @namespaces.dup
+    @namespaces
   end
 
   # Create a new scope and set these options.
@@ -664,7 +603,7 @@ class Puppet::Parser::Scope
     end
 
     # Check for reserved variable names
-    if @enable_immutable_data && !options[:privileged] && RESERVED_VARIABLE_NAMES.include?(name)
+    if !options[:privileged] && RESERVED_VARIABLE_NAMES.include?(name)
       raise Puppet::ParseError, "Attempt to assign to a reserved variable name: '#{name}'"
     end
 
@@ -694,10 +633,6 @@ class Puppet::Parser::Scope
   end
 
   def set_facts(hash)
-    # Remove _timestamp (it has an illegal datatype). It is not allowed to mutate the given hash
-    # since it contains the facts.
-    hash = hash.dup
-    hash.delete('_timestamp')
     setvar('facts', deep_freeze(hash), :privileged => true)
   end
 
@@ -780,8 +715,6 @@ class Puppet::Parser::Scope
     "Scope(#{@resource})"
   end
 
-  alias_method :inspect, :to_s
-
   # remove ephemeral scope up to level
   # TODO: Who uses :all ? Remove ??
   #
@@ -845,7 +778,7 @@ class Puppet::Parser::Scope
   end
 
   def find_defined_resource_type(type)
-    known_resource_types.find_definition(namespaces, type.to_s.downcase)
+    known_resource_types.find_definition(type.to_s.downcase)
   end
 
 
@@ -887,57 +820,34 @@ class Puppet::Parser::Scope
   # Transforms references to classes to the form suitable for
   # lookup in the compiler.
   #
-  # Makes names passed in the names array absolute if they are relative
-  # Names are now made absolute if Puppet.future_parser? is true, this will
-  # be the default behavior in Puppet 4.0
+  # Makes names passed in the names array absolute if they are relative.
   #
-  # Transforms Class[] and Resource[] type referenes to class name
+  # Transforms Class[] and Resource[] type references to class name
   # or raises an error if a Class[] is unspecific, if a Resource is not
   # a 'class' resource, or if unspecific (no title).
   #
-  # TODO: Change this for 4.0 to always make names absolute
   #
   # @param names [Array<String>] names to (optionally) make absolute
   # @return [Array<String>] names after transformation
   #
   def transform_and_assert_classnames(names)
-    if Puppet.future_parser?
-      names.map do |name|
-        case name
-        when String
-          name.sub(/^([^:]{1,2})/, '::\1')
-
-        when Puppet::Resource
-          assert_class_and_title(name.type, name.title)
-          name.title.sub(/^([^:]{1,2})/, '::\1')
-
-        when Puppet::Pops::Types::PHostClassType
-          raise ArgumentError, "Cannot use an unspecific Class[] Type" unless name.class_name
-          name.class_name.sub(/^([^:]{1,2})/, '::\1')
-
-        when Puppet::Pops::Types::PResourceType
-          assert_class_and_title(name.type_name, name.title)
-          name.title.sub(/^([^:]{1,2})/, '::\1')
-        end
+    names.map do |name|
+      case name
+      when String
+        name.sub(/^([^:]{1,2})/, '::\1')
+
+      when Puppet::Resource
+        assert_class_and_title(name.type, name.title)
+        name.title.sub(/^([^:]{1,2})/, '::\1')
+
+      when Puppet::Pops::Types::PHostClassType
+        raise ArgumentError, "Cannot use an unspecific Class[] Type" unless name.class_name
+        name.class_name.sub(/^([^:]{1,2})/, '::\1')
+
+      when Puppet::Pops::Types::PResourceType
+        assert_class_and_title(name.type_name, name.title)
+        name.title.sub(/^([^:]{1,2})/, '::\1')
       end
-    else
-      names
-    end
-  end
-
-  # Calls a 3.x or 4.x function by name with arguments given in an array using the 4.x calling convention
-  # and returns the result.
-  # Note that it is the caller's responsibility to rescue the given ArgumentError and provide location information
-  # to aid the user find the problem. The problem is otherwise reported against the source location that
-  # invoked the function that ultimately called this method.
-  #
-  # @return [Object] the result of the called function
-  # @raise ArgumentError if the function does not exist
-  def call_function(func_name, args, &block)
-    if !Puppet.future_parser?(compiler.environment)
-      return self.send("function_#{func_name}", args, &block)
-    else
-      Puppet::Pops::Parser::EvaluatingParser.new.evaluator.external_call_function(func_name, args, self, &block)
     end
   end