puppet 4.4.2-universal-darwin → 4.5.0-universal-darwin

data/lib/puppet/pops/evaluator/literal_evaluator.rb

@@ -1,5 +1,5 @@
-require 'rgen/ecore/ecore'
-
+module Puppet::Pops
+module Evaluator
 # Literal values for
 # String (not containing interpolation)
 # Numbers
@@ -14,14 +14,13 @@ require 'rgen/ecore/ecore'
 # Not considered literal
 # QualifiedReference  # i.e. File, FooBar
 #
-class Puppet::Pops::Evaluator::LiteralEvaluator
-  #include Puppet::Pops::Utils
+class LiteralEvaluator
 
   EMPTY_STRING = ''.freeze
   COMMA_SEPARATOR = ', '.freeze
 
   def initialize
-    @@literal_visitor ||= Puppet::Pops::Visitor.new(self, "literal", 0, 0)
+    @@literal_visitor ||= Visitor.new(self, "literal", 0, 0)
   end
 
   def literal(ast)
@@ -70,7 +69,7 @@ class Puppet::Pops::Evaluator::LiteralEvaluator
 
   def literal_ConcatenatedString(o)
     # use double quoted string value if there is no interpolation
-    throw :not_literal unless o.segments.size == 1 && o.segments[0].is_a?(Puppet::Pops::Model::LiteralString)
+    throw :not_literal unless o.segments.size == 1 && o.segments[0].is_a?(Model::LiteralString)
     o.segments[0].value
   end
 
@@ -85,3 +84,5 @@ class Puppet::Pops::Evaluator::LiteralEvaluator
     end
   end
 end
+end
+end

data/lib/puppet/pops/evaluator/runtime3_converter.rb

@@ -100,6 +100,18 @@ class Runtime3Converter
   end
   alias :convert2_Regexp :convert_Regexp
 
+  def convert_SemVer(o, scope, undef_value)
+    # Puppet 3x cannot handle SemVers. Use the string form
+    o.to_s
+  end
+  alias :convert2_SemVer :convert_SemVer
+
+  def convert_SemVerRange(o, scope, undef_value)
+    # Puppet 3x cannot handle SemVerRanges. Use the string form
+    o.to_s
+  end
+  alias :convert2_SemVerRange :convert_SemVerRange
+
   def convert_Symbol(o, scope, undef_value)
     case o
       # Support :undef since it may come from a 3x structure
@@ -150,7 +162,7 @@ class Runtime3Converter
         else
           # Ensure that title is '' if nil
           # Resources with absolute name always results in error because tagging does not support leading ::
-          [type_name.nil? ? nil : type_name.sub(/^::/, ''), title.nil? ? '' : title]
+          [type_name.nil? ? nil : type_name.sub(/^::/, '').downcase, title.nil? ? '' : title]
         end
       else
         raise ArgumentError, "Cannot split the type #{catalog_type.class}, it represents neither a PHostClassType, nor a PResourceType."

data/lib/puppet/pops/evaluator/runtime3_support.rb

@@ -82,7 +82,7 @@ module Runtime3Support
       # Must convert :undef back to nil - this can happen when an undefined variable is used in a
       # parameter's default value expression - there nil must be :undef to work with the rest of 3x.
       # Now that the value comes back to 4x it is changed to nil.
-      return (x == :undef) ? nil : x
+      return :undef == x ? nil : x
     }
     # It is always ok to reference numeric variables even if they are not assigned. They are always undef
     # if not set by a match expression.
@@ -90,7 +90,7 @@ module Runtime3Support
     unless name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
       optionally_fail(Puppet::Pops::Issues::UNKNOWN_VARIABLE, o, {:name => name})
     end
-    nil # in case unknown variable is configured as a warning
+    nil # in case unknown variable is configured as a warning or ignore
   end
 
   # Returns true if the variable of the given name is set in the given most nested scope. True is returned even if
@@ -497,7 +497,17 @@ module Runtime3Support
         p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
       end
 
-      p[Issues::UNKNOWN_VARIABLE]             = Puppet[:strict_variables] ? :error : :warning
+      # if strict variables are on, an error is raised
+      # if strict variables are off, the Puppet[strict] defines what is done
+      #
+      if Puppet[:strict_variables]
+        p[Issues::UNKNOWN_VARIABLE] = :error
+      elsif Puppet[:strict] == :off
+        p[Issues::UNKNOWN_VARIABLE] = :ignore
+      else
+        Puppet[:strict_variables]
+        p[Issues::UNKNOWN_VARIABLE] = Puppet[:strict]
+      end
 
       # Store config issues, ignore or warning
       p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
@@ -510,7 +520,7 @@ module Runtime3Support
     def accept(diagnostic)
       super
       IssueReporter.assert_and_report(self, {
-        :message => "Evaluation Error:", 
+        :message => "Evaluation Error:",
         :emit_warnings => true,  # log warnings
         :exception_class => Puppet::PreformattedError
       })

data/lib/puppet/pops/functions/dispatcher.rb

@@ -49,7 +49,7 @@ class Puppet::Pops::Functions::Dispatcher
     add(Puppet::Pops::Functions::Dispatch.new(type, method_name, param_names, block_name, injections, weaving, last_captures))
   end
 
-  # Adds a dispatch directly to the set of dispathers.
+  # Adds a dispatch directly to the set of dispatchers.
   # @api private
   def add(a_dispatch)
     @dispatchers << a_dispatch

data/lib/puppet/pops/issues.rb

@@ -228,6 +228,10 @@ module Issues
     "No value for required key '#{key}' in assignment to variables from hash"
   end
 
+  MISSING_MULTI_ASSIGNMENT_VARIABLE = hard_issue :MISSING_MULTI_ASSIGNMENT_VARIABLE, :name do
+    "No value for required variable '$#{name}' in assignment to variables from class reference"
+  end
+
   APPENDS_DELETES_NO_LONGER_SUPPORTED = hard_issue :APPENDS_DELETES_NO_LONGER_SUPPORTED, :operator do
     "The operator '#{operator}' is no longer supported. See http://links.puppetlabs.com/remove-plus-equals"
   end
@@ -280,6 +284,14 @@ module Issues
     "Illegal name. The given name '#{name}' does not conform to the naming rule /^((::)?[a-z_]\w*)(::[a-z]\\w*)*$/"
   end
 
+  ILLEGAL_SINGLE_TYPE_MAPPING = hard_issue :ILLEGAL_TYPE_MAPPING, :expression do
+    "Illegal type mapping. Expected a Type on the left side, got #{label.a_an_uc(semantic)}"
+  end
+
+  ILLEGAL_REGEXP_TYPE_MAPPING = hard_issue :ILLEGAL_TYPE_MAPPING, :expression do
+    "Illegal type mapping. Expected a Tuple[Regexp,String] on the left side, got #{label.a_an_uc(semantic)}"
+  end
+
   ILLEGAL_PARAM_NAME = hard_issue :ILLEGAL_PARAM_NAME, :name do
     "Illegal parameter name. The given name '#{name}' does not conform to the naming rule /^[a-z_]\\w*$/"
   end
@@ -494,7 +506,7 @@ module Issues
   end
 
   UNKNOWN_RESOURCE_TYPE = issue :UNKNOWN_RESOURCE_TYPE, :type_name do
-    "Resource type not found: #{type_name.capitalize}"
+    "Resource type not found: #{type_name}"
   end
 
   ILLEGAL_RESOURCE_TYPE = hard_issue :ILLEGAL_RESOURCE_TYPE, :actual do
@@ -526,7 +538,7 @@ module Issues
   end
 
   UNKNOWN_RESOURCE = issue :UNKNOWN_RESOURCE, :type_name, :title do
-    "Resource not found: #{type_name.capitalize}['#{title}']"
+    "Resource not found: #{type_name}['#{title}']"
   end
 
   UNKNOWN_RESOURCE_PARAMETER = issue :UNKNOWN_RESOURCE_PARAMETER, :type_name, :title, :param_name do
@@ -594,6 +606,10 @@ module Issues
     "The parameter '#{param_name}' is declared more than once in the parameter list"
   end
 
+  DUPLICATE_KEY = issue :DUPLICATE_KEY, :key do
+    "The key '#{key}' is declared more than once"
+  end
+
   RESERVED_PARAMETER = hard_issue :RESERVED_PARAMETER, :container, :param_name do
     "The parameter $#{param_name} redefines a built in parameter in #{label.the(container)}"
   end

data/lib/puppet/pops/loader/base_loader.rb

@@ -38,6 +38,18 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
     end
   end
 
+  # @api public
+  #
+  def loaded_entry(typed_name, check_dependencies = false)
+    if @named_values.has_key?(typed_name)
+      @named_values[typed_name]
+    elsif parent
+      parent.loaded_entry(typed_name, check_dependencies)
+    else
+      nil
+    end
+  end
+
   # This method is final (subclasses should not override it)
   #
   # @api private
@@ -49,8 +61,24 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
   # @api private
   #
   def set_entry(typed_name, value, origin = nil)
-    if entry = @named_values[typed_name] then fail_redefine(entry); end
-    @named_values[typed_name] = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, value, origin)
+
+    # It is never ok to redefine in the very same loader unless redefining a 'not found'
+    if entry = @named_values[typed_name]
+      fail_redefine(entry) unless entry.value.nil?
+    end
+
+    # Check if new entry shadows existing entry and fail
+    # (unless special loader allows shadowing)
+    if typed_name.type == :type && !allow_shadowing?
+      entry = loaded_entry(typed_name)
+      if entry
+        fail_redefine(entry) unless entry.value.nil? #|| entry.value == value
+      end
+    end
+
+    @last_result = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, value, origin)
+    @last_name = typed_name
+    @named_values[typed_name] = @last_result
   end
 
   # @api private
@@ -69,25 +97,35 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
     @named_values[typed_name] = named_entry
   end
 
+  protected
+
+  def allow_shadowing?
+    false
+  end
+
   private
 
   def fail_redefine(entry)
-    origin_info = entry.origin ? " Originally set at #{origin_label(entry.origin)}." : "unknown location"
-    raise ArgumentError, "Attempt to redefine entity '#{entry.typed_name}' originally set at #{origin_info}"
+    origin_info = entry.origin ? "Originally set #{origin_label(entry.origin)}." : "Set at unknown location"
+    raise ArgumentError, "Attempt to redefine entity '#{entry.typed_name}'. #{origin_info}"
   end
 
   # TODO: Should not really be here?? - TODO: A Label provider ? semantics for the URI?
   #
   def origin_label(origin)
     if origin && origin.is_a?(URI)
-      origin.to_s
+      format_uri(origin)
     elsif origin.respond_to?(:uri)
-      origin.uri.to_s
+      format_uri(origin.uri)
     else
       origin
     end
   end
 
+  def format_uri(uri)
+    (uri.scheme == 'puppet' ? 'by ' : 'at ') + uri.to_s.sub(/^puppet:/,'')
+  end
+
   # loads in priority order:
   # 1. already loaded here
   # 2. load from parent
@@ -96,7 +134,10 @@ class Puppet::Pops::Loader::BaseLoader < Puppet::Pops::Loader::Loader
   #
   def internal_load(typed_name)
     # avoid calling get_entry, by looking it up
-    @named_values[typed_name] || parent.load_typed(typed_name) || find(typed_name)
+    te = @named_values[typed_name]
+    te = parent.load_typed(typed_name) if te.nil? || te.value.nil?
+    te = find(typed_name) if te.nil? || te.value.nil?
+    te
   end
 
 end

data/lib/puppet/pops/loader/dependency_loader.rb

@@ -48,13 +48,38 @@ class Puppet::Pops::Loader::DependencyLoader < Puppet::Pops::Loader::BaseLoader
     end
   end
 
-  def to_s()
+  # @api public
+  #
+  def loaded_entry(typed_name, check_dependencies = false)
+    super || (check_dependencies ? loaded_entry_in_dependency(typed_name, check_dependencies) : nil)
+  end
+
+  def to_s
     "(DependencyLoader '#{@loader_name}' [" + @dependency_loaders.map {|loader| loader.to_s }.join(' ,') + "])"
   end
 
   private
 
-  def index()
+  def loaded_entry_in_dependency(typed_name, check_dependencies)
+    if typed_name.qualified?
+      if l = index[typed_name.name_parts[0]]
+        l.loaded_entry(typed_name)
+      else
+        # no module entered as dependency with name matching first segment of wanted name
+        nil
+      end
+    else
+      # a non name-spaced name, have to search since it can be anywhere.
+      # (Note: superclass caches the result in this loader as it would have to repeat this search for every
+      # lookup otherwise).
+      @dependency_loaders.reduce(nil) do |previous, loader|
+        break previous if !previous.nil?
+        loader.loaded_entry(typed_name, check_dependencies)
+      end
+    end
+  end
+
+  def index
     @index ||= @dependency_loaders.reduce({}) { |index, loader| index[loader.module_name] = loader; index }
   end
 end

data/lib/puppet/pops/loader/loader.rb

@@ -55,6 +55,18 @@ class Puppet::Pops::Loader::Loader
     raise NotImplementedError.new
   end
 
+  # Returns an already loaded entry if one exists, or nil. This does not trigger loading
+  # of the given type/name.
+  #
+  # @param typed_name [TypedName] - the type, name combination to lookup
+  # @param check_dependencies [Boolean] - if dependencies should be checked in additiona to here and parent
+  # @return [NamedEntry, nil] the entry containing the loaded value, or nil if not found
+  # @api public
+  #
+  def loaded_entry(typed_name, check_dependencies = false)
+    raise NotImplementedError.new(self.class)
+  end
+
   # Produces the value associated with the given name if defined **in this loader**, or nil if not defined.
   # This lookup does not trigger any loading, or search of the given name.
   # An implementor of this method may not search or look up in any other loader, and it may not

data/lib/puppet/pops/loader/predefined_loader.rb

@@ -0,0 +1,29 @@
+module Puppet::Pops::Loader
+
+# A PredefinedLoader is a loader that is manually populated with loaded elements
+# before being used. It never loads anything on its own.
+# When searching for a type, it must exist or an error is raised
+#
+class PredefinedLoader < BaseLoader
+  def find(typed_name)
+    if typed_name.type == :type
+      raise Puppet::Pops::Loaders::LoaderError, "Cannot load undefined type '#{typed_name.name.capitalize}'"
+    else
+      nil
+    end
+  end
+
+  def to_s()
+    "(PredefinedLoader '#{loader_name}')"
+  end
+
+  # Allows shadowing since this loader is used internally for things like function local types
+  # And they should win as there is otherwise a risk that the local types clash with built in types
+  # that were added after the function was written, or by resource types loaded by the 3x auto loader.
+  #
+  def allow_shadowing?
+    true
+  end
+end
+
+end

data/lib/puppet/pops/loader/runtime3_type_loader.rb

@@ -0,0 +1,57 @@
+module Puppet::Pops
+module Loader
+
+# Runtime3TypeLoader
+# ===
+# Loads a resource type using the 3.x type loader
+#
+# @api private
+class Runtime3TypeLoader < BaseLoader
+  def initialize(parent_loader, environment)
+    super(parent_loader, environment.name)
+    @environment = environment
+  end
+
+  def to_s()
+    "(Runtime3TypeLoader '#{loader_name()}')"
+  end
+
+  # Finds typed/named entity in this module
+  # @param typed_name [TypedName] the type/name to find
+  # @return [Loader::NamedEntry, nil found/created entry, or nil if not found
+  #
+  def find(typed_name)
+    return nil unless typed_name.type == :type
+
+    name = typed_name.name
+    value = @environment.known_resource_types.find_definition(name)
+    if value.nil?
+      # Look for Puppet::Type
+      value = Puppet::Type.type(name)
+      if value.nil?
+        # Cache the fact that it wasn't found
+        set_entry(typed_name, nil)
+        return nil
+      end
+    end
+
+    # Loaded types doesn't have the same life cycle as this loader, so we must start by
+    # checking if the type was created. If it was, an entry will already be stored in
+    # this loader. If not, then it was created before this loader was instantiated and
+    # we must therefore add it.
+    te = get_entry(typed_name)
+    te = set_entry(typed_name, Types::TypeFactory.resource(value.name.to_s)) if te.nil? || te.value.nil?
+    te
+  end
+
+  # Allows shadowing since this loader is populalted with all loaded resource types at time
+  # of loading. This loading will, for built in types override the aliases configured in the static
+  # loader.
+  #
+  def allow_shadowing?
+    true
+  end
+
+end
+end
+end

data/lib/puppet/pops/loader/static_loader.rb

@@ -1,12 +1,16 @@
   # Static Loader contains constants, basic data types and other types required for the system
   # to boot.
   #
-class Puppet::Pops::Loader::StaticLoader < Puppet::Pops::Loader::Loader
+module Puppet::Pops
+module Loader
+class StaticLoader < Loader
 
   attr_reader :loaded
   def initialize
     @loaded = {}
     create_logging_functions()
+    create_built_in_types()
+    create_resource_type_references()
   end
 
   def load_typed(typed_name)
@@ -29,14 +33,17 @@ class Puppet::Pops::Loader::StaticLoader < Puppet::Pops::Loader::Loader
   def to_s()
     "(StaticLoader)"
   end
-  private
 
-  def load_constant(typed_name)
+  def loaded_entry(typed_name, _)
     @loaded[typed_name]
   end
 
   private
 
+  def load_constant(typed_name)
+    @loaded[typed_name]
+  end
+
   # Creates a function for each of the specified log levels
   #
   def create_logging_functions()
@@ -70,10 +77,90 @@ class Puppet::Pops::Loader::StaticLoader < Puppet::Pops::Loader::Loader
         end
       end
 
-      typed_name = Puppet::Pops::Loader::Loader::TypedName.new(:function, level)
+      typed_name = TypedName.new(:function, level)
       # TODO:closure scope is fake (an empty hash) - waiting for new global scope to be available via lookup of :scopes
       func = fc.new({},self)
-      @loaded[ typed_name ] = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, func, __FILE__)
+      @loaded[ typed_name ] = NamedEntry.new(typed_name, func, __FILE__)
+    end
+  end
+
+  def create_built_in_types
+    origin_uri = URI("puppet:Puppet-Type-System/Static-Loader")
+    type_map = Puppet::Pops::Types::TypeParser.type_map
+    type_map.each do |name, type|
+      typed_name = TypedName.new(:type, name)
+      @loaded[ typed_name ] = NamedEntry.new(typed_name, type, origin_uri)#__FILE__)
     end
   end
+
+  def create_resource_type_references()
+    # These needs to be done quickly and we do not want to scan the file system for these
+    # We are also not interested in their definition only that they exist.
+    # These types are in all environments.
+    #
+    %w{
+      Auegas
+      Component
+      Computer
+      Cron
+      Exec
+      File
+      Filebucket
+      Group
+      Host
+      Interface
+      K5login
+      Macauthorization
+      Mailalias
+      Maillist
+      Mcx
+      Mount
+      Nagios_command
+      Nagios_contact
+      Nagios_contactgroup
+      Nagios_host
+      Nagios_hostdependency
+      Nagios_hostescalation
+      Nagios_hostgroup
+      Nagios_hostextinfo
+      Nagios_service
+      Nagios_servicedependency
+      Nagios_serviceescalation
+      Nagios_serviceextinfo
+      Nagios_servicegroup
+      Nagios_timeperiod
+      Notify
+      Package
+      Resources
+      Router
+      Schedule
+      Scheduled_task
+      Selboolean
+      Selmodule
+      Service
+      Ssh_authorized_key
+      Sshkey
+      Stage
+      Tidy
+      User
+      Vlan
+      Whit
+      Yumrepo
+      Zfs
+      Zone
+      Zpool
+    }.each { |name| create_resource_type_reference(name) }
+
+    if Puppet[:app_management]
+      create_resource_type_reference('Node')
+    end
+  end
+
+  def create_resource_type_reference(name)
+    typed_name = TypedName.new(:type, name.downcase)
+    type = Puppet::Pops::Types::TypeFactory.resource(name)
+    @loaded[ typed_name ] = NamedEntry.new(typed_name, type, __FILE__)
+  end
+end
+end
 end