puppet 4.1.0 → 5.0.0

data/lib/puppet/functions.rb

@@ -44,7 +44,15 @@
 # When the function is called, puppet searches the signatures for one that
 # matches the supplied arguments. Each signature is part of a dispatch, which
 # specifies the method that should be called for that signature. When a
-# matching signature is found, the corrosponding method is called.
+# matching signature is found, the corresponding method is called.
+#
+# Special dispatches designed to create error messages for an argument mismatch
+# can be added using the keyword `argument_mismatch` instead of `dispatch`. The
+# method appointed by an `argument_mismatch` will be called with arguments
+# just like a normal `dispatch` would, but the method must produce a string.
+# The string is then used as the message in the `ArgumentError` that is raised
+# when the method returns. A block parameter can be given, but it is not
+# propagated in the method call.
 #
 # Documentation for the function should be placed as comments to the
 # implementation method(s).
@@ -73,6 +81,27 @@
 #     end
 #   end
 #
+# @example Using an argument mismatch handler
+#   Puppet::Functions.create_function('math::min') do
+#     dispatch :numeric_min do
+#       param 'Numeric', :a
+#       param 'Numeric', :b
+#     end
+#
+#     argument_mismatch :on_error do
+#       param 'Any', :a
+#       param 'Any', :b
+#     end
+#
+#     def numeric_min(a, b)
+#       a <= b ? a : b
+#     end
+#
+#     def on_error(a, b)
+#       'both arguments must be of type Numeric'
+#     end
+#   end
+#
 # Specifying Signatures
 # ---
 #
@@ -153,8 +182,30 @@ module Puppet::Functions
   #
   # @api public
   def self.create_function(func_name, function_base = Function, &block)
+    # Ruby < 2.1.0 does not have method on Binding, can only do eval
+    # and it will fail unless protected with an if defined? if the local
+    # variable does not exist in the block's binder.
+    #
+    loader = block.binding.eval('loader_injected_arg if defined?(loader_injected_arg)')
+    create_loaded_function(func_name, loader, function_base, &block)
+  end
+
+  # Creates a function in, or in a local loader under the given loader.
+  # This method should only be used when manually creating functions
+  # for the sake of testing. Functions that are autoloaded should
+  # always use the `create_function` method and the autoloader will supply
+  # the correct loader.
+  #
+  # @param func_name [String, Symbol] a simple or qualified function name
+  # @param loader [Puppet::Pops::Loaders::Loader] the loader loading the function
+  # @param block [Proc] the block that defines the methods and dispatch of the
+  #   Function to create
+  # @return [Class<Function>] the newly created Function class
+  #
+  # @api public
+  def self.create_loaded_function(func_name, loader, function_base = Function, &block)
     if function_base.ancestors.none? { |s| s == Puppet::Pops::Functions::Function }
-      raise ArgumentError, "Functions must be based on Puppet::Pops::Functions::Function. Got #{function_base}"
+      raise ArgumentError, _("Functions must be based on Puppet::Pops::Functions::Function. Got %{function_base}") % { function_base: function_base }
     end
 
     func_name = func_name.to_s
@@ -162,7 +213,12 @@ module Puppet::Functions
     # The idea being that it is garbage collected when there are no more
     # references to it.
     #
-    the_class = Class.new(function_base, &block)
+    # (Do not give the class the block here, as instance variables should be set first)
+    the_class = Class.new(function_base)
+
+    unless loader.nil?
+      the_class.instance_variable_set(:'@loader', loader.private_loader)
+    end
 
     # Make the anonymous class appear to have the class-name <func_name>
     # Even if this class is not bound to such a symbol in a global ruby scope and
@@ -175,11 +231,20 @@ module Puppet::Functions
     #
     the_class.instance_eval do
       @func_name = func_name
+
       def name
         @func_name
       end
+
+      def loader
+        @loader
+      end
     end
 
+    # The given block can now be evaluated and have access to name and loader
+    #
+    the_class.class_eval(&block)
+
     # Automatically create an object dispatcher based on introspection if the
     # loaded user code did not define any dispatchers. Fail if function name
     # does not match a given method name in user code.
@@ -188,7 +253,7 @@ module Puppet::Functions
       simple_name = func_name.split(/::/)[-1]
       type, names = default_dispatcher(the_class, simple_name)
       last_captures_rest = (type.size_range[1] == Float::INFINITY)
-      the_class.dispatcher.add_dispatch(type, simple_name, names, nil, nil, nil, last_captures_rest)
+      the_class.dispatcher.add(Puppet::Pops::Functions::Dispatch.new(type, simple_name, names, last_captures_rest))
     end
 
     # The function class is returned as the result of the create function method
@@ -200,7 +265,7 @@ module Puppet::Functions
   # @api private
   def self.default_dispatcher(the_class, func_name)
     unless the_class.method_defined?(func_name)
-      raise ArgumentError, "Function Creation Error, cannot create a default dispatcher for function '#{func_name}', no method with this name found"
+      raise ArgumentError, _("Function Creation Error, cannot create a default dispatcher for function '%{func_name}', no method with this name found") % { func_name: func_name }
     end
     any_signature(*min_max_param(the_class.instance_method(func_name)))
   end
@@ -222,8 +287,8 @@ module Puppet::Functions
   def self.any_signature(from, to, names)
     # Construct the type for the signature
     # Tuple[Object, from, to]
-    factory = Puppet::Pops::Types::TypeFactory
-    [factory.callable(factory.any, from, to), names]
+    param_types = Puppet::Pops::Types::PTupleType.new([Puppet::Pops::Types::PAnyType::DEFAULT], Puppet::Pops::Types::PIntegerType.new(from, to))
+    [Puppet::Pops::Types::PCallableType.new(param_types), names]
   end
 
   # Function
@@ -236,9 +301,7 @@ module Puppet::Functions
 
     # @api private
     def self.builder
-      @type_parser ||= Puppet::Pops::Types::TypeParser.new
-      @all_callables ||= Puppet::Pops::Types::TypeFactory.all_callables
-      DispatcherBuilder.new(dispatcher, @type_parser, @all_callables)
+      DispatcherBuilder.new(dispatcher, Puppet::Pops::Types::TypeParser.singleton, Puppet::Pops::Types::PCallableType::DEFAULT, loader)
     end
 
     # Dispatch any calls that match the signature to the provided method name.
@@ -251,9 +314,63 @@ module Puppet::Functions
     # @api public
     def self.dispatch(meth_name, &block)
       builder().instance_eval do
-        dispatch(meth_name, &block)
+        dispatch(meth_name, false, &block)
       end
     end
+
+    # Like `dispatch` but used for a specific type of argument mismatch. Will not be include in the list of valid
+    # parameter overloads for the function.
+    #
+    # @param meth_name [Symbol] The name of the implementation method to call
+    #   when the signature defined in the block matches the arguments to a call
+    #   to the function.
+    # @return [Void]
+    #
+    # @api public
+    def self.argument_mismatch(meth_name, &block)
+      builder().instance_eval do
+        dispatch(meth_name, true, &block)
+      end
+    end
+
+    # Allows types local to the function to be defined to ease the use of complex types
+    # in a 4.x function. Within the given block, calls to `type` can be made with a string
+    # 'AliasType = ExistingType` can be made to define aliases. The defined aliases are
+    # available for further aliases, and in all dispatchers.
+    #
+    # @since 4.5.0
+    # @api public
+    #
+    def self.local_types(&block)
+      if loader.nil?
+        raise ArgumentError, _("No loader present. Call create_loaded_function(:myname, loader,...), instead of 'create_function' if running tests")
+      end
+      aliases = LocalTypeAliasesBuilder.new(loader, name)
+      aliases.instance_eval(&block)
+      # Add the loaded types to the builder
+      aliases.local_types.each do |type_alias_expr|
+        # Bind the type alias to the local_loader using the alias
+        t = Puppet::Pops::Loader::TypeDefinitionInstantiator.create_from_model(type_alias_expr, aliases.loader)
+
+        # Also define a method for convenient access to the defined type alias.
+        # Since initial capital letter in Ruby means a Constant these names use a prefix of
+        # `type`. As an example, the type 'MyType' is accessed by calling `type_MyType`.
+        define_method("type_#{t.name}") { t }
+      end
+      # Store the loader in the class
+      @loader = aliases.loader
+    end
+
+    # Creates a new function instance in the given closure scope (visibility to variables), and a loader
+    # (visibility to other definitions). The created function will either use the `given_loader` or
+    # (if it has local type aliases) a loader that was constructed from the loader used when loading
+    # the function's class.
+    #
+    # TODO: It would be of value to get rid of the second parameter here, but that would break API.
+    #
+    def self.new(closure_scope, given_loader)
+      super(closure_scope, @loader || given_loader)
+    end
   end
 
   # Base class for all functions implemented in the puppet language
@@ -269,11 +386,14 @@ module Puppet::Functions
   #
   # @api public
   class DispatcherBuilder
+    attr_reader :loader
+
     # @api private
-    def initialize(dispatcher, type_parser, all_callables)
+    def initialize(dispatcher, type_parser, all_callables, loader)
       @type_parser = type_parser
       @all_callables = all_callables
       @dispatcher = dispatcher
+      @loader = loader
     end
 
     # Defines a required positional parameter with _type_ and _name_.
@@ -287,7 +407,7 @@ module Puppet::Functions
     # @api public
     def param(type, name)
       internal_param(type, name)
-      raise ArgumentError, 'A required parameter cannot be added after an optional parameter' if @min != @max
+      raise ArgumentError, _('A required parameter cannot be added after an optional parameter') if @min != @max
       @min += 1
       @max += 1
     end
@@ -336,7 +456,7 @@ module Puppet::Functions
     # @api public
     def required_repeated_param(type, name)
       internal_param(type, name, true)
-      raise ArgumentError, 'A required repeated parameter cannot be added after an optional parameter' if @min != @max
+      raise ArgumentError, _('A required repeated parameter cannot be added after an optional parameter') if @min != @max
       @min += 1
       @max = :default
     end
@@ -349,33 +469,31 @@ module Puppet::Functions
     def block_param(*type_and_name)
       case type_and_name.size
       when 0
-        # the type must be an independent instance since it will be contained in another type
-        type = @all_callables.copy
+        type = @all_callables
         name = :block
       when 1
-        # the type must be an independent instance since it will be contained in another type
-        type = @all_callables.copy
+        type = @all_callables
         name = type_and_name[0]
       when 2
         type_string, name = type_and_name
-        type = @type_parser.parse(type_string)
+        type = @type_parser.parse(type_string, loader)
       else
-        raise ArgumentError, "block_param accepts max 2 arguments (type, name), got #{type_and_name.size}."
+        raise ArgumentError, _("block_param accepts max 2 arguments (type, name), got %{size}.") % { size: type_and_name.size }
       end
 
       unless Puppet::Pops::Types::TypeCalculator.is_kind_of_callable?(type, false)
-        raise ArgumentError, "Expected PCallableType or PVariantType thereof, got #{type.class}"
+        raise ArgumentError, _("Expected PCallableType or PVariantType thereof, got %{type_class}") % { type_class: type.class }
       end
 
       unless name.is_a?(Symbol)
-        raise ArgumentError, "Expected block_param name to be a Symbol, got #{name.class}"
+        raise ArgumentError, _("Expected block_param name to be a Symbol, got %{name_class}") % { name_class: name.class }
       end
 
       if @block_type.nil?
         @block_type = type
         @block_name = name
       else
-        raise ArgumentError, 'Attempt to redefine block'
+        raise ArgumentError, _('Attempt to redefine block')
       end
     end
     alias required_block_param block_param
@@ -391,15 +509,24 @@ module Puppet::Functions
       @block_type = Puppet::Pops::Types::TypeFactory.optional(@block_type)
     end
 
+    # Defines the return type. Defaults to 'Any'
+    # @param [String] type a reference to a Puppet Data Type
+    #
+    # @api public
+    def return_type(type)
+      raise ArgumentError, _("Argument to 'return_type' must be a String reference to a Puppet Data Type. Got %{type_class}") % { type_class: type.class } unless type.is_a?(String)
+      @return_type = type
+    end
+
     private
 
     # @api private
     def internal_param(type, name, repeat = false)
-      raise ArgumentError, 'Parameters cannot be added after a block parameter' unless @block_type.nil?
-      raise ArgumentError, 'Parameters cannot be added after a repeated parameter' if @max == :default
+      raise ArgumentError, _('Parameters cannot be added after a block parameter') unless @block_type.nil?
+      raise ArgumentError, _('Parameters cannot be added after a repeated parameter') if @max == :default
 
       if name.is_a?(String)
-        raise ArgumentError, "Parameter name argument must be a Symbol. Got #{name.class}"
+        raise ArgumentError, _("Parameter name argument must be a Symbol. Got %{name_class}") % { name_class: name.class }
       end
 
       if type.is_a?(String)
@@ -412,12 +539,12 @@ module Puppet::Functions
           @weaving << @names.size()-1
         end
       else
-        raise ArgumentError, "Parameter 'type' must be a String reference to a Puppet Data Type. Got #{type.class}"
+        raise ArgumentError, _("Parameter 'type' must be a String reference to a Puppet Data Type. Got %{type_class}") % { type_class: type.class }
       end
     end
 
     # @api private
-    def dispatch(meth_name, &block)
+    def dispatch(meth_name, argument_mismatch_handler, &block)
       # an array of either an index into names/types, or an array with
       # injection information [type, name, injection_name] used when the call
       # is being made to weave injections into the given arguments.
@@ -430,9 +557,11 @@ module Puppet::Functions
       @max = 0
       @block_type = nil
       @block_name = nil
+      @return_type = nil
+      @argument_mismatch_hander = argument_mismatch_handler
       self.instance_eval &block
-      callable_t = create_callable(@types, @block_type, @min, @max)
-      @dispatcher.add_dispatch(callable_t, meth_name, @names, @block_name, @injections, @weaving, @max == :default)
+      callable_t = create_callable(@types, @block_type, @return_type, @min, @max)
+      @dispatcher.add(Puppet::Pops::Functions::Dispatch.new(callable_t, meth_name, @names, @max == :default, @block_name, @injections, @weaving, @argument_mismatch_hander))
     end
 
     # Handles creation of a callable type from strings specifications of puppet
@@ -441,22 +570,43 @@ module Puppet::Functions
     # Optional[Callable], Callable, or nil.
     #
     # @api private
-    def create_callable(types, block_type, from, to)
+    def create_callable(types, block_type, return_type, from, to)
       mapped_types = types.map do |t|
-        @type_parser.parse(t)
+        @type_parser.parse(t, loader)
       end
+      param_types = Puppet::Pops::Types::PTupleType.new(mapped_types, from > 0 && from == to ? nil : Puppet::Pops::Types::PIntegerType.new(from, to))
+      return_type = @type_parser.parse(return_type, loader) unless return_type.nil?
+      Puppet::Pops::Types::PCallableType.new(param_types, block_type, return_type)
+    end
+  end
 
-      if from != to
-        # :optional and/or :repeated parameters are present.
-        mapped_types << from
-        mapped_types << to
-      end
+  # The LocalTypeAliasBuilder is used by the 'local_types' method to collect the individual
+  # type aliases given by the function's author.
+  #
+  class LocalTypeAliasesBuilder
+    attr_reader :local_types, :parser, :loader
+
+    def initialize(loader, name)
+      @loader = Puppet::Pops::Loader::PredefinedLoader.new(loader, :"local_function_#{name}")
+      @local_types = []
+      # get the shared parser used by puppet's compiler
+      @parser = Puppet::Pops::Parser::EvaluatingParser.singleton()
+    end
 
-      if block_type
-        mapped_types << block_type
+    # Defines a local type alias, the given string should be a Puppet Language type alias expression
+    # in string form without the leading 'type' keyword.
+    # Calls to local_type must be made before the first parameter definition or an error will
+    # be raised.
+    #
+    # @param assignment_string [String] a string on the form 'AliasType = ExistingType'
+    # @api public
+    #
+    def type(assignment_string)
+      result = parser.parse_string("type #{assignment_string}", nil) # no file source :-(
+      unless result.body.kind_of?(Puppet::Pops::Model::TypeAlias)
+        raise ArgumentError, _("Expected a type alias assignment on the form 'AliasType = T', got '%{assignment_string}'") % { assignment_string: assignment_string }
       end
-
-      Puppet::Pops::Types::TypeFactory.callable(*mapped_types)
+      @local_types << result.body
     end
   end
 
@@ -496,37 +646,7 @@ module Puppet::Functions
   class InternalFunction < Function
     # @api private
     def self.builder
-      @type_parser ||= Puppet::Pops::Types::TypeParser.new
-      @all_callables ||= Puppet::Pops::Types::TypeFactory.all_callables
-      InternalDispatchBuilder.new(dispatcher, @type_parser, @all_callables)
-    end
-
-    # Defines class level injected attribute with reader method
-    #
-    # @api private
-    def self.attr_injected(type, attribute_name, injection_name = nil)
-      define_method(attribute_name) do
-        ivar = :"@#{attribute_name.to_s}"
-        unless instance_variable_defined?(ivar)
-          injector = Puppet.lookup(:injector)
-          instance_variable_set(ivar, injector.lookup(closure_scope, type, injection_name))
-        end
-        instance_variable_get(ivar)
-      end
-    end
-
-    # Defines class level injected producer attribute with reader method
-    #
-    # @api private
-    def self.attr_injected_producer(type, attribute_name, injection_name = nil)
-      define_method(attribute_name) do
-        ivar = :"@#{attribute_name.to_s}"
-        unless instance_variable_defined?(ivar)
-          injector = Puppet.lookup(:injector)
-          instance_variable_set(ivar, injector.lookup_producer(closure_scope, type, injection_name))
-        end
-        instance_variable_get(ivar)
-      end
+      InternalDispatchBuilder.new(dispatcher, Puppet::Pops::Types::TypeParser.singleton, Puppet::Pops::Types::PCallableType::DEFAULT, loader)
     end
 
     # Allows the implementation of a function to call other functions by name and pass the caller
@@ -539,8 +659,8 @@ module Puppet::Functions
     # @return [Object] The result returned by the called function
     #
     # @api public
-    def call_function_with_scope(scope, function_name, *args)
-      internal_call_function(scope, function_name, args)
+    def call_function_with_scope(scope, function_name, *args, &block)
+      internal_call_function(scope, function_name, args, &block)
     end
   end
 

data/lib/puppet/generate/models/type/property.rb

@@ -0,0 +1,70 @@
+module Puppet
+  module Generate
+    module Models
+      module Type
+        # A model for resource type properties and parameters.
+        class Property
+          # Gets the name of the property as a Puppet string literal.
+          attr_reader :name
+
+          # Gets the Puppet type of the property.
+          attr_reader :type
+
+          # Gets the doc string of the property.
+          attr_reader :doc
+
+          # Initializes a property model.
+          # @param property [Puppet::Property] The Puppet property to model.
+          # @return [void]
+          def initialize(property)
+            @name = Puppet::Pops::Types::StringConverter.convert(property.name.to_s, '%p')
+            @type = self.class.get_puppet_type(property)
+            @doc = property.doc.strip
+            @is_namevar = property.isnamevar?
+          end
+
+          # Determines if this property is a namevar.
+          # @return [Boolean] Returns true if the property is a namevar or false if not.
+          def is_namevar?
+            @is_namevar
+          end
+
+          # Gets the Puppet type for a property.
+          # @param property [Puppet::Property] The Puppet property to get the Puppet type for.
+          # @return [String] Returns the string representing the Puppet type.
+          def self.get_puppet_type(property)
+            # HACK: the value collection does not expose the underlying value information at all
+            #       thus this horribleness to get the underlying values hash
+            regexes = []
+            strings = []
+            values = property.value_collection.instance_variable_get('@values') || {}
+            values.each do |_, value|
+              if value.regex?
+                regexes << "/#{value.name.source.gsub(/\//, '\/')}/"
+                next
+              end
+
+              strings << Puppet::Pops::Types::StringConverter.convert(value.name.to_s, '%p')
+              value.aliases.each do |a|
+                strings << Puppet::Pops::Types::StringConverter.convert(a.to_s, '%p')
+              end
+            end
+
+            # If no string or regexes, default to Any type
+            return 'Any' if strings.empty? && regexes.empty?
+
+            # Calculate a variant of supported values
+            # Note that boolean strings are mapped to Variant[Boolean, Enum['true', 'false']]
+            # because of tech debt...
+            enum    = strings.empty? ? nil : "Enum[#{strings.join(', ')}]"
+            pattern = regexes.empty? ? nil : "Pattern[#{regexes.join(', ')}]"
+            boolean = strings.include?('\'true\'') || strings.include?('\'false\'') ? 'Boolean' : nil
+            variant = [boolean, enum, pattern].reject { |t| t.nil? }
+            return variant[0] if variant.size == 1
+            "Variant[#{variant.join(', ')}]"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppet/generate/models/type/type.rb

@@ -0,0 +1,62 @@
+require 'puppet/generate/models/type/property'
+
+module Puppet
+  module Generate
+    module Models
+      module Type
+        # A model for Puppet resource types.
+        class Type
+          # Gets the name of the type as a Puppet string literal.
+          attr_reader :name
+
+          # Gets the doc string of the type.
+          attr_reader :doc
+
+          # Gets the properties of the type.
+          attr_reader :properties
+
+          # Gets the parameters of the type.
+          attr_reader :parameters
+
+          # Gets the title patterns of the type
+          attr_reader :title_patterns
+
+          # Gets the isomorphic member attribute of the type
+          attr_reader :isomorphic
+
+          # Gets the capability member attribute of the type
+          attr_reader :capability
+
+          # Initializes a type model.
+          # @param type [Puppet::Type] The Puppet type to model.
+          # @return [void]
+          def initialize(type)
+            @name = Puppet::Pops::Types::StringConverter.convert(type.name.to_s, '%p')
+            @doc = type.doc.strip
+            @properties = type.properties.map { |p| Property.new(p) }
+            @parameters = type.parameters.map do |name|
+              Property.new(type.paramclass(name))
+            end
+            sc = Puppet::Pops::Types::StringConverter.singleton
+            @title_patterns = Hash[type.title_patterns.map do |mapping|
+              [
+                sc.convert(mapping[0], '%p'),
+                sc.convert(mapping[1].map do |names|
+                  next if names.empty?
+                  raise Puppet::Error, _('title patterns that use procs are not supported.') unless names.size == 1
+                  names[0].to_s
+                end, '%p')
+              ]
+            end]
+            @isomorphic = type.isomorphic?
+            @capability = type.is_capability?
+          end
+
+          def render(template)
+            template.result(binding)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppet/generate/templates/type/pcore.erb

@@ -0,0 +1,42 @@
+# This file was automatically generated on <%= Time.now %>.
+# Use the 'puppet generate types' command to regenerate this file.
+
+<%- unless doc.empty? -%>
+  <%- doc.each_line do |line| -%>
+# <%= line -%>
+  <%- end %>
+<%- end -%>
+Puppet::Resource::ResourceType3.new(
+  <%= name %>,
+  [
+<%- properties.each_with_index do |property, index| -%>
+  <%- unless property.doc.empty? -%>
+    <%- property.doc.each_line do |line| -%>
+    # <%= line -%>
+    <%- end %>
+  <%- end -%>
+    Puppet::Resource::Param(<%= property.type %>, <%= property.name %><% if property.is_namevar? %>, true<% end %>)<% if index + 1 < properties.size %>,
+
+    <%- end -%>
+<%- end %>
+  ],
+  [
+<%- parameters.each_with_index do |parameter, index| -%>
+  <%- unless parameter.doc.empty? -%>
+    <%- parameter.doc.each_line do |line| -%>
+    # <%= line -%>
+    <%- end %>
+  <%- end -%>
+    Puppet::Resource::Param(<%= parameter.type %>, <%= parameter.name %><% if parameter.is_namevar? %>, true<% end %>)<% if index + 1 < parameters.size %>,
+
+    <%- end -%>
+<%- end %>
+  ],
+  {
+<%- title_patterns.each_with_index do |mapping, index| -%>
+    <%= mapping[0] %> => <%= mapping[1] %><%= "," if index + 1 < title_patterns.size %>
+<%- end -%>
+  },
+  <%= isomorphic -%>,
+  <%= capability -%>
+)