puppet 3.8.7 → 4.0.0

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
 

data/lib/puppet/parser/templatewrapper.rb

@@ -1,6 +1,5 @@
 require 'puppet/parser/files'
 require 'erb'
-require 'puppet/file_system'
 
 # A simple wrapper for templates, so they don't have full access to
 # the scope objects.
@@ -59,38 +58,11 @@ class Puppet::Parser::TemplateWrapper
     scope.catalog.tags
   end
 
-  # Ruby treats variables like methods, so we used to expose variables
-  # within scope to the ERB code via method_missing.  As per RedMine #1427,
-  # though, this means that conflicts between methods in our inheritance
-  # tree (Kernel#fork) and variable names (fork => "yes/no") could arise.
-  #
-  # Worse, /new/ conflicts could pop up when a new kernel or object method
-  # was added to Ruby, causing templates to suddenly fail mysteriously when
-  # Ruby was upgraded.
-  #
-  # To ensure that legacy templates using unqualified names work we retain
-  # the missing_method definition here until we declare the syntax finally
-  # dead.
-  def method_missing(name, *args)
-    line_number = script_line
-    if scope.include?(name.to_s)
-      Puppet.deprecation_warning("Variable access via '#{name}' is deprecated. Use '@#{name}' instead. #{to_s}:#{line_number}")
-      return scope[name.to_s, { :file => @__file__, :line => line_number }]
-    else
-      # Just throw an error immediately, instead of searching for
-      # other missingmethod things or whatever.
-      raise Puppet::ParseError.new("Could not find value for '#{name}'", @__file__, line_number)
-    end
-  end
-
   # @api private
   def file=(filename)
     unless @__file__ = Puppet::Parser::Files.find_template(filename, scope.compiler.environment)
       raise Puppet::ParseError, "Could not find template '#{filename}'"
     end
-
-    # We'll only ever not have a parser in testing, but, eh.
-    scope.known_resource_types.watch_file(@__file__)
   end
 
   # @api private
@@ -98,7 +70,7 @@ class Puppet::Parser::TemplateWrapper
     if string
       template_source = "inline template"
     else
-      string = Puppet::FileSystem.read_preserve_line_endings(@__file__)
+      string = File.read(@__file__)
       template_source = @__file__
     end
 

data/lib/puppet/parser/type_loader.rb

@@ -1,11 +1,12 @@
 require 'find'
 require 'forwardable'
-require 'puppet/node/environment'
 require 'puppet/parser/parser_factory'
 
 class Puppet::Parser::TypeLoader
   extend  Forwardable
 
+  class TypeLoaderError < StandardError; end
+
   # Import manifest files that match a given file glob pattern.
   #
   # @param pattern [String] the file glob to apply when determining which files
@@ -14,12 +15,10 @@ class Puppet::Parser::TypeLoader
   #   found in a module
   # @api private
   def import(pattern, dir)
-    return if Puppet[:ignoreimport]
-
     modname, files = Puppet::Parser::Files.find_manifests_in_modules(pattern, environment)
     if files.empty?
       abspat = File.expand_path(pattern, dir)
-      file_pattern = abspat + (File.extname(abspat).empty? ? '{.pp,.rb}' : '' )
+      file_pattern = abspat + (File.extname(abspat).empty? ? '.pp' : '' )
 
       files = Dir.glob(file_pattern).uniq.reject { |f| FileTest.directory?(f) }
       modname = nil
@@ -68,10 +67,10 @@ class Puppet::Parser::TypeLoader
       begin
         imported_types = import_from_modules(filename)
         if result = imported_types.find { |t| t.type == type and t.name == fqname }
-          Puppet.debug "Automatically imported #{fqname} from #{filename} into #{environment}"
+          Puppet.debug {"Automatically imported #{fqname} from #{filename} into #{environment}"}
           return result
         end
-      rescue Puppet::ImportError => detail
+      rescue TypeLoaderError => detail
         # I'm not convienced we should just drop these errors, but this
         # preserves existing behaviours.
       end
@@ -82,7 +81,7 @@ class Puppet::Parser::TypeLoader
 
   def parse_file(file)
     Puppet.debug("importing '#{file}' in environment #{environment}")
-    parser = Puppet::Parser::ParserFactory.parser(environment)
+    parser = Puppet::Parser::ParserFactory.parser
     parser.file = file
     return parser.parse
   end
@@ -99,24 +98,22 @@ class Puppet::Parser::TypeLoader
   end
 
   def raise_no_files_found(pattern)
-    raise Puppet::ImportError, "No file(s) found for import of '#{pattern}'"
+    raise TypeLoaderError, "No file(s) found for import of '#{pattern}'"
   end
 
   def load_files(modname, files)
     @loaded ||= {}
     loaded_asts = []
     files.reject { |file| @loaded[file] }.each do |file|
-      # NOTE: This ugly implementation will be replaced in Puppet 3.5.
-      # The implementation now makes use of a global variable because the context support is
-      # not available until Puppet 3.5.
-      # The use case is that parsing for the purpose of searching for information
-      # should not abort. There is currently one such use case in indirector/resourcetype/parser
-      #
+    # The squelch_parse_errors use case is for parsing for the purpose of searching
+    # for information and it should not abort.
+    # There is currently one user in indirector/resourcetype/parser
+    #
     if Puppet.lookup(:squelch_parse_errors) {|| false }
         begin
           loaded_asts << parse_file(file)
         rescue => e
-          # Resume from errors so that all parseable files would
+          # Resume from errors so that all parseable files may
           # still be parsed. Mark this file as loaded so that
           # it would not be parsed next time (handle it as if
           # it was successfully parsed).

data/lib/puppet/parser.rb

@@ -1,7 +1,17 @@
-# @api public
+# is only needed to create the name space
 module Puppet::Parser; end
 
-require 'puppet/parser/parser'
+require 'puppet/parser/ast'
 require 'puppet/parser/compiler'
 require 'puppet/resource/type_collection'
 
+require 'puppet/parser/functions'
+require 'puppet/parser/files'
+require 'puppet/parser/relationship'
+
+require 'puppet/resource/type_collection_helper'
+require 'puppet/resource/type'
+require 'monitor'
+
+# PUP-3274 This should probably go someplace else
+class Puppet::LexError < RuntimeError; end

data/lib/{puppetx/puppet/bindings_scheme_handler.rb → puppet/plugins/binding_schemes.rb}

@@ -1,4 +1,14 @@
-module Puppetx::Puppet
+require 'puppet/plugins'
+module Puppet::Plugins::BindingSchemes
+
+  # The lookup **key** for the multibind containing a map from scheme name to scheme handler class for bindings schemes.
+  # @api public
+  BINDINGS_SCHEMES_KEY  = 'puppet::binding::schemes'
+
+  # The lookup **type** for the multibind containing a map from scheme name to scheme handler class for bindings schemes.
+  # @api public
+  BINDINGS_SCHEMES_TYPE = 'Puppet::Plugins::BindingSchemes::BindingsSchemeHandler'
+
   # BindingsSchemeHandler is a Puppet Extension Point for the purpose of extending Puppet with a
   # handler of a URI scheme used in the Puppet Bindings / Injector system.
   # The intended use is to create a class derived from this class and then register it with the
@@ -9,7 +19,7 @@ module Puppetx::Puppet
   # As an example, a class for getting LDAP data and transforming into bindings based on an LDAP URI scheme (such as RFC 2255, 4516)
   # may be authored in say a puppet module called 'exampleorg/ldap'. The name of the class should start with `Puppetx::<user>::<module>`,
   # e.g. 'Puppetx::Exampleorg::Ldap::LdapBindingsSchemeHandler" and
-  # be located in `lib/puppetx/exampleorg/Ldap/LdapBindingsSchemeHandler.rb`. (These rules are not enforced, but it make the class
+  # be located in `lib/puppetx/exampleorg/Ldap/LdapBindingsSchemeHandler.rb`. (These rules are not enforced, but it makes the class
   # both auto-loadable, and guaranteed to not have a name that clashes with some other LdapBindingsSchemeHandler from some other
   # author/organization.
   #
@@ -29,7 +39,7 @@ module Puppetx::Puppet
   #
   # The expand_included method
   # --------------------------
-  # This method is given a URI (as entred by a user in a bindings configuration) and the handler's first task is to
+  # This method is given a URI (as entered by a user in a bindings configuration) and the handler's first task is to
   # perform checking, transformation, and possible expansion into multiple URIs for loading. The result is always an array
   # of URIs. This method allows users to enter wild-cards, or to represent something symbolic that is transformed into one or
   # more "real URIs" to load. (It is allowed to change scheme!).
@@ -71,7 +81,6 @@ module Puppetx::Puppet
   # @api public
   #
   class BindingsSchemeHandler
-
     # Produces the bindings contributed to the binding system based on the given URI.
     # @param uri [URI] the URI to load bindings from
     # @param scope [Puppet::Pops::Parser::Scope] access to scope and the rest of the environment
@@ -127,4 +136,5 @@ module Puppetx::Puppet
       (query = uri.query) && query == '' || query == 'optional'
     end
   end
+
 end