puppet 4.0.0 → 4.9.1

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

@@ -20,7 +20,7 @@ module Puppet::Pops::Evaluator::ExternalSyntaxSupport
     # Call checker and give it the location information from the expression
     # (as opposed to where the heredoc tag is (somewhere on the line above)).
     acceptor = Puppet::Pops::Validation::Acceptor.new()
-    source_pos = find_closest_positioned(reference_expr)
+    source_pos = Puppet::Pops::Utils.find_closest_positioned(reference_expr)
     checker.check(result, syntax, acceptor, source_pos)
 
     if acceptor.error_count > 0

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

@@ -0,0 +1,84 @@
+require 'rgen/ecore/ecore'
+
+# Literal values for
+#
+#   * String
+#   * Numbers
+#   * Booleans
+#   * Undef (produces nil)
+#   * Array
+#   * Hash where keys must be Strings
+#   * QualifiedName
+#
+# Not considered literal:
+#
+#   * QualifiedReference  # i.e. File, FooBar
+#   * Default is not accepted as being literal
+#   * Regular Expression is not accepted as being literal
+#   * Hash with non String keys
+#   * String with interpolation
+#
+class Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator
+  #include Puppet::Pops::Utils
+
+  COMMA_SEPARATOR = ', '.freeze
+
+  def initialize
+    @@literal_visitor ||= Puppet::Pops::Visitor.new(self, "literal", 0, 0)
+  end
+
+  def literal(ast)
+    @@literal_visitor.visit_this_0(self, ast)
+  end
+
+  def literal_Object(o)
+    throw :not_literal
+  end
+
+  def literal_Factory(o)
+    literal(o.model)
+  end
+
+  def literal_Program(o)
+    literal(o.body)
+  end
+
+  def literal_LiteralString(o)
+    o.value
+  end
+
+  def literal_QualifiedName(o)
+    o.value
+  end
+
+  def literal_LiteralNumber(o)
+    o.value
+  end
+
+  def literal_LiteralBoolean(o)
+    o.value
+  end
+
+  def literal_LiteralUndef(o)
+    nil
+  end
+
+  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)
+    o.segments[0].value
+  end
+
+  def literal_LiteralList(o)
+    o.values.map {|v| literal(v) }
+  end
+
+  def literal_LiteralHash(o)
+    o.entries.reduce({}) do |result, entry|
+      key = literal(entry.key)
+      throw :not_literal unless key.is_a?(String)
+      result[key] = literal(entry.value)
+      result
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+module Puppet::Pops
+module Evaluator
+# Literal values for
+# String (not containing interpolation)
+# Numbers
+# Booleans
+# Undef (produces nil)
+# Array
+# Hash
+# QualifiedName
+# Default (produced :default)
+# Regular Expression (produces ruby reqular expression)
+#
+# Not considered literal
+# QualifiedReference  # i.e. File, FooBar
+#
+class LiteralEvaluator
+
+  COMMA_SEPARATOR = ', '.freeze
+
+  def initialize
+    @@literal_visitor ||= Visitor.new(self, "literal", 0, 0)
+  end
+
+  def literal(ast)
+    @@literal_visitor.visit_this_0(self, ast)
+  end
+
+  def literal_Object(o)
+    throw :not_literal
+  end
+
+  def literal_Factory(o)
+    literal(o.model)
+  end
+
+  def literal_Program(o)
+    literal(o.body)
+  end
+
+  def literal_LiteralString(o)
+    o.value
+  end
+
+  def literal_QualifiedName(o)
+    o.value
+  end
+
+  def literal_LiteralNumber(o)
+    o.value
+  end
+
+  def literal_LiteralBoolean(o)
+    o.value
+  end
+
+  def literal_LiteralUndef(o)
+    nil
+  end
+
+  def literal_LiteralDefault(o)
+    :default
+  end
+
+  def literal_LiteralRegularExpression(o)
+    o.value
+  end
+
+  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?(Model::LiteralString)
+    o.segments[0].value
+  end
+
+  def literal_LiteralList(o)
+    o.values.map {|v| literal(v) }
+  end
+
+  def literal_LiteralHash(o)
+    o.entries.reduce({}) do |result, entry|
+      result[literal(entry.key)] = literal(entry.value)
+      result
+    end
+  end
+end
+end
+end

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

@@ -1,3 +1,5 @@
+module Puppet::Pops
+module Evaluator
 # The RelationshipOperator implements the semantics of the -> <- ~> <~ operators creating relationships or notification
 # relationships between the left and right hand side's references to resources.
 #
@@ -6,14 +8,12 @@
 # This is done to separate the concerns of the new evaluator from the 3x runtime; messy logic goes into the runtime support
 # module. Later when more is cleaned up this can be simplified further.
 #
-class Puppet::Pops::Evaluator::RelationshipOperator
+class RelationshipOperator
 
   # Provides access to the Puppet 3.x runtime (scope, etc.)
   # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
   #
-  include Puppet::Pops::Evaluator::Runtime3Support
-
-  Issues = Puppet::Pops::Issues
+  include Runtime3Support
 
   class IllegalRelationshipOperandError < RuntimeError
     attr_reader :operand
@@ -30,11 +30,10 @@ class Puppet::Pops::Evaluator::RelationshipOperator
   end
 
   def initialize
-    @type_transformer_visitor = Puppet::Pops::Visitor.new(self, "transform", 1, 1)
-    @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
-    @type_parser = Puppet::Pops::Types::TypeParser.new()
+    @type_transformer_visitor = Visitor.new(self, "transform", 1, 1)
+    @type_calculator = Types::TypeCalculator.new()
 
-    tf = Puppet::Pops::Types::TypeFactory
+    tf = Types::TypeFactory
     @catalog_type = tf.variant(tf.catalog_entry, tf.type_type(tf.catalog_entry))
   end
 
@@ -48,16 +47,22 @@ class Puppet::Pops::Evaluator::RelationshipOperator
     raise IllegalRelationshipOperandError.new(o)
   end
 
+  # A Resource is by definition a Catalog type, but of 3.x type
+  # @api private
+  def transform_Resource(o, scope)
+    Types::TypeFactory.resource(o.type, o.title)
+  end
+
   # A string must be a type reference in string format
   # @api private
   def transform_String(o, scope)
-    assert_catalog_type(@type_parser.parse(o), scope)
+    assert_catalog_type(Types::TypeParser.singleton.parse(o, scope), scope)
   end
 
   # A qualified name is short hand for a class with this name
   # @api private
   def transform_QualifiedName(o, scope)
-    Puppet::Pops::Types::TypeFactory.host_class(o.value)
+    Types::TypeFactory.host_class(o.value)
   end
 
   # Types are what they are, just check the type
@@ -149,7 +154,7 @@ class Puppet::Pops::Evaluator::RelationshipOperator
       # Produce the transformed source RHS (if this is a chain, this does not need to be done again)
       real.slice(1)
     rescue NotCatalogTypeError => e
-      fail(Issues::ILLEGAL_RELATIONSHIP_OPERAND_TYPE, relationship_expression, {:type => @type_calculator.string(e.type)})
+      fail(Issues::NOT_CATALOG_TYPE, relationship_expression, {:type => @type_calculator.string(e.type)})
     rescue IllegalRelationshipOperandError => e
       fail(Issues::ILLEGAL_RELATIONSHIP_OPERAND_TYPE, relationship_expression, {:operand => e.operand})
     end
@@ -159,3 +164,5 @@ class Puppet::Pops::Evaluator::RelationshipOperator
     REVERSE_OPERATORS.include?(o.operator)
   end
 end
+end
+end

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

@@ -15,7 +15,7 @@ class Runtime3Converter
   # @return [Array] The converted values
   #
   def self.map_args(args, scope, undef_value)
-    @@instance.map_args(args, scope, undef_value)
+    @instance.map_args(args, scope, undef_value)
   end
 
   # Converts 4x supported values to a 3x values. Same as calling Runtime3Converter.instance.convert(...)
@@ -26,13 +26,13 @@ class Runtime3Converter
   # @return [Object] The converted value
   #
   def self.convert(o, scope, undef_value)
-    @@instance.convert(o, scope, undef_value)
+    @instance.convert(o, scope, undef_value)
   end
 
   # Returns the singleton instance of this class.
   # @return [Runtime3Converter] The singleton instance
   def self.instance
-    @@instance
+    @instance
   end
 
   # Converts 4x supported values to a 3x values.
@@ -58,62 +58,41 @@ class Runtime3Converter
   end
 
   def convert_NilClass(o, scope, undef_value)
-    undef_value
-  end
-
-  def convert2_NilClass(o, scope, undef_value)
-    :undef
+    @inner ? :undef : undef_value
   end
 
   def convert_String(o, scope, undef_value)
     # although wasteful, needed because user code may mutate these strings in Resources
     o.frozen? ? o.dup : o
   end
-  alias convert2_String :convert_String
 
   def convert_Object(o, scope, undef_value)
     o
   end
-  alias :convert2_Object :convert_Object
 
   def convert_Array(o, scope, undef_value)
-    o.map {|x| convert2(x, scope, undef_value) }
+    ic = @inner_converter
+    o.map {|x| ic.convert(x, scope, undef_value) }
   end
-  alias :convert2_Array :convert_Array
 
   def convert_Hash(o, scope, undef_value)
     result = {}
-    o.each {|k,v| result[convert2(k, scope, undef_value)] = convert2(v, scope, undef_value) }
+    ic = @inner_converter
+    o.each {|k,v| result[ic.convert(k, scope, undef_value)] = ic.convert(v, scope, undef_value) }
     result
   end
-  alias :convert2_Hash :convert_Hash
 
-  def convert_Regexp(o, scope, undef_value)
-    # Puppet 3x cannot handle parameter values that are reqular expressions. Turn into regexp string in
-    # source form
-    o.inspect
+  def convert_Iterator(o, scope, undef_value)
+    raise Puppet::Error, 'Use of an Iterator is not supported here'
   end
-  alias :convert2_Regexp :convert_Regexp
 
   def convert_Symbol(o, scope, undef_value)
-    case o
-      # Support :undef since it may come from a 3x structure
-      when :undef
-        undef_value  # 3x wants undef as either empty string or :undef
-      else
-        o   # :default, and all others are verbatim since they are new in future evaluator
-    end
-  end
-
-  # The :undef symbol should not be converted when nested in arrays or hashes
-  def convert2_Symbol(o, scope, undef_value)
-    o
+    o == :undef && !@inner ? undef_value : o
   end
 
   def convert_PAnyType(o, scope, undef_value)
     o
   end
-  alias :convert2_PAnyType :convert_PAnyType
 
   def convert_PCatalogEntryType(o, scope, undef_value)
     # Since 4x does not support dynamic scoping, all names are absolute and can be
@@ -121,10 +100,10 @@ class Runtime3Converter
     # due to Puppet::Resource's idiosyncratic behavior where some references must be
     # absolute and others cannot be.
     # Thus there is no need to call scope.resolve_type_and_titles to do dynamic lookup.
-
-    Puppet::Resource.new(*catalog_type_to_split_type_title(o))
+    t, title = catalog_type_to_split_type_title(o)
+    t = Runtime3ResourceSupport.find_resource_type(scope, t) unless t == 'class' || t == 'node'
+    Puppet::Resource.new(t, title)
   end
-  alias :convert2_PCatalogEntryType :convert_PCatalogEntryType
 
   # Produces an array with [type, title] from a PCatalogEntryType
   # This method is used to produce the arguments for creation of reference resource instances
@@ -140,36 +119,66 @@ class Runtime3Converter
       when Puppet::Pops::Types::PResourceType
         type_name = split_type.type_name
         title = split_type.title
-        if type_name =~ /^(::)?[Cc]lass/
+        if type_name =~ /^(::)?[Cc]lass$/
           ['class', title.nil? ? nil : title.sub(/^::/, '')]
         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."
     end
   end
 
-  private
+  protected
 
-  def initialize
-    @convert_visitor  = Puppet::Pops::Visitor.new(self, 'convert', 2, 2)
-    @convert2_visitor = Puppet::Pops::Visitor.new(self, 'convert2', 2, 2)
+  def initialize(inner = false)
+    @inner = inner
+    @inner_converter = inner ? self : self.class.new(true)
+    @convert_visitor = Puppet::Pops::Visitor.new(self, 'convert', 2, 2)
   end
 
-  @@instance = self.new
+  @instance = self.new
+end
 
-  # Converts a nested 4x supported value to a 3x value.
-  #
-  # @param o [Object]The value to convert
-  # @param scope [Puppet::Parser::Scope] The scope to use when converting
-  # @param undef_value [Object] The value that nil is converted to
-  # @return [Object] The converted value
-  #
-  def convert2(o, scope, undef_value)
-    @convert2_visitor.visit_this_2(self, o, scope, undef_value)
+# A Ruby function written for the 3.x API cannot be expected to handle extended data types. This
+# converter ensures that they are converted to String format
+# @api private
+class Runtime3FunctionArgumentConverter < Runtime3Converter
+
+  def convert_Regexp(o, scope, undef_value)
+    # Puppet 3x cannot handle parameter values that are reqular expressions. Turn into regexp string in
+    # source form
+    o.inspect
+  end
+
+  def convert_Version(o, scope, undef_value)
+    # Puppet 3x cannot handle SemVers. Use the string form
+    o.to_s
+  end
+
+  def convert_VersionRange(o, scope, undef_value)
+    # Puppet 3x cannot handle SemVerRanges. Use the string form
+    o.to_s
+  end
+
+  def convert_Binary(o, scope, undef_value)
+    # Puppet 3x cannot handle Binary. Use the string form
+    o.to_s
+  end
+
+  def convert_Timespan(o, scope, undef_value)
+    # Puppet 3x cannot handle Timespans. Use the string form
+    o.to_s
   end
+
+  def convert_Timestamp(o, scope, undef_value)
+    # Puppet 3x cannot handle Timestamps. Use the string form
+    o.to_s
+  end
+
+  @instance = self.new
 end
+
 end

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

@@ -0,0 +1,119 @@
+module Puppet::Pops
+module Evaluator
+
+# @api private
+module Runtime3ResourceSupport
+  CLASS_STRING = 'class'.freeze
+
+  def self.create_resources(file, line, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
+
+    env = scope.environment
+    #    loader = Adapters::LoaderAdapter.loader_for_model_object(o, scope)
+
+    if type_name.is_a?(String) && type_name.casecmp(CLASS_STRING) == 0
+      # Resolve a 'class' and its titles
+      resource_titles = resource_titles.collect do |a_title|
+        hostclass = env.known_resource_types.find_hostclass(a_title)
+        hostclass ?  hostclass.name : a_title
+      end
+      # resolved type is just the string CLASS
+      resolved_type = CLASS_STRING
+    else
+      # resolve a resource type - pcore based, ruby impl, user defined, or application
+      resolved_type = find_resource_type(scope, type_name)
+    end
+
+    # TODO: Unknown resource causes creation of Resource to fail with ArgumentError, should give
+    # a proper Issue. Now the result is "Error while evaluating a Resource Statement" with the message
+    # from the raised exception. (It may be good enough).
+    unless resolved_type
+      # TODO: do this the right way
+      raise ArgumentError, "Unknown resource type: '#{type_name}'"
+    end
+
+    # Build a resource for each title - use the resolved *type* as opposed to a reference
+    # as this makes the created resource retain the type instance.
+    #
+    resource_titles.map do |resource_title|
+        resource = Puppet::Parser::Resource.new(
+          resolved_type, resource_title,
+          :parameters => evaluated_parameters,
+          :file => file,
+          :line => line,
+          :exported => exported,
+          :virtual => virtual,
+          # WTF is this? Which source is this? The file? The name of the context ?
+          :source => scope.source,
+          :scope => scope,
+          :strict => true
+        )
+
+        # If this resource type supports inheritance (e.g. 'class') the parent chain must be walked
+        # This impl delegates to the resource type to figure out what is needed.
+        #
+        if resource.resource_type.is_a? Puppet::Resource::Type
+          resource.resource_type.instantiate_resource(scope, resource)
+        end
+
+        scope.compiler.add_resource(scope, resource)
+
+        # Classes are evaluated immediately
+        scope.compiler.evaluate_classes([resource_title], scope, false) if resolved_type == CLASS_STRING
+
+        # Turn the resource into a PType (a reference to a resource type)
+        # weed out nil's
+        resource_to_ptype(resource)
+    end
+  end
+
+  def self.find_resource_type(scope, type_name)
+    type_name = type_name.to_s.downcase
+    find_builtin_resource_type(scope, type_name) || find_defined_resource_type(scope, type_name)
+  end
+
+  def self.find_resource_type_or_class(scope, name)
+    type_name = type_name.to_s.downcase
+    find_builtin_resource_type(scope, name) || find_defined_resource_type(scope, name) || find_hostclass(scope, name)
+  end
+
+  def self.resource_to_ptype(resource)
+    nil if resource.nil?
+    # inference returns the meta type since the 3x Resource is an alternate way to describe a type
+    Puppet::Pops::Types::TypeCalculator.singleton().infer(resource).type
+  end
+
+  def self.find_main_class(scope)
+    # Find the main class (known as ''), it does not have to be in the catalog
+    scope.environment.known_resource_types.find_hostclass('')
+  end
+
+  def self.find_hostclass(scope, class_name)
+    scope.environment.known_resource_types.find_hostclass(class_name)
+  end
+
+  private
+
+  def self.find_builtin_resource_type(scope, type_name)
+    if type_name.include?(':')
+      # Skip the search for built in types as they are always in global namespace
+      # (At least for now).
+      return nil
+    end
+
+    loader = scope.compiler.loaders.private_environment_loader
+    if loaded = loader.load(:resource_type_pp, type_name)
+      return loaded
+    end
+
+    # horrible - should be loaded by a "last loader" in 4.x loaders instead.
+    Puppet::Type.type(type_name)
+  end
+
+  def self.find_defined_resource_type(scope, type_name)
+    krt = scope.environment.known_resource_types
+    krt.find_definition(type_name) || krt.application(type_name)
+  end
+
+end
+end
+end