puppet 4.7.1-x64-mingw32 → 4.8.0-x64-mingw32

data/lib/puppet/parser/resource.rb

@@ -156,7 +156,7 @@ class Puppet::Parser::Resource < Puppet::Resource
     # Test the resource scope, to make sure the resource is even allowed
     # to override.
     unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
-      raise Puppet::ParseError.new("Only subclasses can override parameters", resource.line, resource.file)
+      raise Puppet::ParseError.new("Only subclasses can override parameters", resource.file, resource.line)
     end
     # Some of these might fail, but they'll fail in the way we want.
     resource.parameters.each do |name, param|
@@ -176,6 +176,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   # the resource tags with its value.
   def set_parameter(param, value = nil)
     if ! param.is_a?(Puppet::Parser::Resource::Param)
+      param = param.name if param.is_a?(Puppet::Pops::Resource::Param)
       param = Puppet::Parser::Resource::Param.new(
         :name => param, :value => value, :source => self.source
       )
@@ -191,13 +192,13 @@ class Puppet::Parser::Resource < Puppet::Resource
   def to_hash
     @parameters.reduce({}) do |result, (_, param)|
       value = param.value
-      value = (value == :undef) ? nil : value
+      value = (:undef == value) ? nil : value
 
       unless value.nil?
         case param.name
         when :before, :subscribe, :notify, :require
           if value.is_a?(Array)
-            value = value.flatten.reject {|v| v.nil? || v == :undef }
+            value = value.flatten.reject {|v| v.nil? || :undef == v }
           end
           result[param.name] = value
         else
@@ -244,7 +245,9 @@ class Puppet::Parser::Resource < Puppet::Resource
       raise Puppet::Error, "Invalid consume in #{self.ref}: #{ref} is not a resource" unless ref.is_a?(Puppet::Resource)
 
       # Resolve references
-      cap = catalog.resource(ref.type, ref.title)
+      t = ref.type
+      t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t) unless t == 'class' || t == 'node'
+      cap = catalog.resource(t, ref.title)
       if cap.nil?
         raise "Resource #{ref} could not be found; it might not have been produced yet"
       end
@@ -342,7 +345,7 @@ class Puppet::Parser::Resource < Puppet::Resource
         msg += " at #{fields.join(":")}"
       end
       msg += "; cannot redefine"
-      raise Puppet::ParseError.new(msg, param.line, param.file)
+      raise Puppet::ParseError.new(msg, param.file, param.line)
     end
 
     # If we've gotten this far, we're allowed to override.

data/lib/puppet/parser/scope.rb

@@ -710,7 +710,7 @@ class Puppet::Parser::Scope
 
     params.each { |param|
       if table.include?(param.name)
-        raise Puppet::ParseError.new("Default already defined for #{type} { #{param.name} }; cannot redefine", param.line, param.file)
+        raise Puppet::ParseError.new("Default already defined for #{type} { #{param.name} }; cannot redefine", param.file, param.line)
       end
       table[param.name] = param
     }

data/lib/puppet/plugins/configuration.rb

@@ -65,5 +65,13 @@ module Puppet::Plugins::Configuration
       in_multibind(checkers_name)
       to_instance('Puppet::SyntaxCheckers::Json')
     end
+
+    bindings.bind do
+      name('base64')
+      instance_of(checkers_type)
+      in_multibind(checkers_name)
+      to_instance('Puppet::SyntaxCheckers::Base64')
+    end
+
     Puppet::Plugins::DataProviders::Registry.register_defaults(bindings)
 end

data/lib/puppet/plugins/data_providers.rb

@@ -1,5 +1,6 @@
 module Puppet::Plugins; end
 
+# @api private
 module Puppet::Plugins::DataProviders
 
   # The lookup **key** for the multibind containing data provider name per module

data/lib/puppet/plugins/data_providers/data_provider.rb

@@ -1,6 +1,7 @@
 require 'puppet/pops/lookup/interpolation'
 
 module Puppet::Plugins::DataProviders
+  # @api private
   module DataProvider
     include Puppet::Pops::Lookup::Interpolation
 
@@ -9,8 +10,6 @@ module Puppet::Plugins::DataProviders
     # @param key [String] The key to lookup
     # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
     # @param merge [String|Hash<String,Object>|nil] Merge strategy or hash with strategy and options
-    #
-    # @api public
     def lookup(name, lookup_invocation, merge)
       lookup_invocation.check(name) { unchecked_lookup(name, lookup_invocation, merge) }
     end
@@ -20,8 +19,6 @@ module Puppet::Plugins::DataProviders
     # @param key [String] The key to lookup
     # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
     # @param merge [String|Hash<String,Object>|nil] Merge strategy or hash with strategy and options
-    #
-    # @api public
     def unchecked_lookup(key, lookup_invocation, merge)
       segments = split_key(key)
       root_key = segments.shift
@@ -44,8 +41,6 @@ module Puppet::Plugins::DataProviders
     # @param value [Object] The value to perform post processing on
     # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
     # @return [Object] The result of post processing the value.
-    #
-    # @api public
     def post_process(value, lookup_invocation)
       interpolate(value, lookup_invocation, true)
     end
@@ -61,8 +56,6 @@ module Puppet::Plugins::DataProviders
     # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
     # @param merge [String|Hash<String,Object>|nil] Merge strategy or hash with strategy and options
     # @return [Hash] The data hash for the given _key_
-    #
-    # @api public
     def data(data_key, lookup_invocation)
       compiler = lookup_invocation.scope.compiler
       adapter = Puppet::DataProviders::DataAdapter.get(compiler) || Puppet::DataProviders::DataAdapter.adapt(compiler)
@@ -74,8 +67,6 @@ module Puppet::Plugins::DataProviders
     #
     # @param key [String] The key to lookup
     # @return [String,nil] The data key or nil if not applicable
-    #
-    # @api public
     def data_key(key, lookup_invocation)
       nil
     end
@@ -85,8 +76,6 @@ module Puppet::Plugins::DataProviders
     # @param data_key [String] The data key such as the name of a module or the constant 'environment'
     # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
     # @return [Hash] The hash of values
-    #
-    # @api public
     def initialize_data(data_key, lookup_invocation)
       {}
     end
@@ -102,6 +91,7 @@ module Puppet::Plugins::DataProviders
     end
   end
 
+  # @api private
   class ModuleDataProvider
     LOOKUP_OPTIONS = Puppet::Pops::Lookup::LOOKUP_OPTIONS
     include DataProvider
@@ -142,6 +132,7 @@ module Puppet::Plugins::DataProviders
     end
   end
 
+  # @api private
   class EnvironmentDataProvider
     include DataProvider
 
@@ -153,13 +144,12 @@ module Puppet::Plugins::DataProviders
   # Class that keeps track of the original path (as it appears in the declaration, before interpolation),
   # the fully resolved path, and whether or the resolved path exists.
   #
-  # @api public
+  # @api private
   class ResolvedPath
     attr_reader :original_path, :path
 
     # @param original_path [String] path as found in declaration. May contain interpolation expressions
     # @param path [Pathname] the expanded absolute path
-    # @api public
     def initialize(original_path, path)
       @original_path = original_path
       @path = path
@@ -179,7 +169,7 @@ module Puppet::Plugins::DataProviders
   # will be merged according to a given (optional) merge strategy.
   #
   # @abstract
-  # @api public
+  # @api private
   class PathBasedDataProvider
     include DataProvider
 
@@ -188,8 +178,6 @@ module Puppet::Plugins::DataProviders
     # @param name [String] The name of the data provider
     # @param paths [Array<ResolvedPath>] Paths used by this provider
     # @param parent_data_provider [DataProvider] The data provider that is the container of this data provider
-    #
-    # @api public
     def initialize(name, paths, parent_data_provider = nil)
       @name = name
       @paths = paths
@@ -208,8 +196,6 @@ module Puppet::Plugins::DataProviders
     # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
     # @param merge [String|Hash<String,Object>|nil] Merge strategy or hash with strategy and options
     # @return [Hash] The data hash for the given _key_
-    #
-    # @api public
     def load_data(path, data_key, lookup_invocation)
       compiler = lookup_invocation.scope.compiler
       adapter = Puppet::DataProviders::DataAdapter.get(compiler) || Puppet::DataProviders::DataAdapter.adapt(compiler)
@@ -227,8 +213,6 @@ module Puppet::Plugins::DataProviders
     # @param key [String] The key to lookup
     # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
     # @param merge [Puppet::Pops::MergeStrategy,String,Hash<String,Object>,nil] Merge strategy or hash with strategy and options
-    #
-    # @api public
     def unchecked_lookup(key, lookup_invocation, merge)
       segments = split_key(key)
       root_key = segments.shift
@@ -264,7 +248,7 @@ module Puppet::Plugins::DataProviders
   # Factory for creating path based data providers
   #
   # @abstract
-  # @api public
+  # @api private
   class PathBasedDataProviderFactory
     # Create a path based data provider with the given _name_ and _paths_
     #
@@ -272,8 +256,6 @@ module Puppet::Plugins::DataProviders
     # @param paths [Array<String>] array of resolved paths
     # @param parent_data_provider [DataProvider] The data provider that is the container of this data provider
     # @return [DataProvider] The created data provider
-    #
-    # @api public
     def create(name, paths, parent_data_provider)
       raise NotImplementedError, "Subclass of PathBasedDataProviderFactory must implement 'create' method"
     end
@@ -289,8 +271,6 @@ module Puppet::Plugins::DataProviders
     # @param paths [Array<String>] paths that have been preprocessed (interpolations resolved)
     # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
     # @return [Array<ResolvedPath>] Array of resolved paths
-    #
-    # @api public
     def resolve_paths(datadir, declared_paths, paths, lookup_invocation)
       []
     end
@@ -298,7 +278,6 @@ module Puppet::Plugins::DataProviders
     # Returns the data provider factory version.
     #
     # return [Integer] the version of this data provider factory
-    # @api public
     def version
       2
     end
@@ -309,7 +288,7 @@ module Puppet::Plugins::DataProviders
   # file system.
   #
   # @abstract
-  # @api public
+  # @api private
   class FileBasedDataProviderFactory < PathBasedDataProviderFactory
     # @param datadir [Pathname] The base when creating absolute paths
     # @param declared_paths [Array<String>] paths as found in declaration. May contain interpolation expressions

data/lib/puppet/plugins/data_providers/registry.rb

@@ -1,3 +1,4 @@
+# @api private
 module Puppet::Plugins::DataProviders
   class Registry
     def self.register_extensions(extensions)

data/lib/puppet/pops.rb

@@ -41,9 +41,13 @@ module Puppet
 
     require 'puppet/pops/model/model'
 
+    require 'puppet/pops/time/timespan'
+    require 'puppet/pops/time/timestamp'
+
     # (the Types module initializes itself)
     require 'puppet/pops/types/types'
     require 'puppet/pops/types/string_converter'
+    require 'puppet/pops/lookup/context'
 
     require 'puppet/pops/merge_strategy'
 

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

@@ -30,6 +30,10 @@ class AccessOperator
     fail(Issues::OPERATOR_NOT_APPLICABLE, @semantic.left_expr, :operator=>'[]', :left_value => o)
   end
 
+  def access_Binary(o, scope, keys)
+    Puppet::Pops::Types::PBinaryType::Binary.from_binary_string(access_String(o.binary_buffer, scope, keys))
+  end
+
   def access_String(o, scope, keys)
     keys.flatten!
     result = case keys.size
@@ -37,8 +41,8 @@ class AccessOperator
       fail(Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       # Note that Ruby 1.8.7 requires a length of 1 to produce a String
-      k1 = coerce_numeric(keys[0], @semantic.keys[0], scope)
-      bad_access_key_type(o, 0, k1, Integer) unless k1.is_a?(Integer)
+      k1 = Utils.to_n(keys[0])
+      bad_string_access_key_type(o, 0, k1.nil? ? keys[0] : k1) unless k1.is_a?(Integer)
       k2 = 1
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos
       # if k1 is outside, a length of 1 always produces an empty string
@@ -48,9 +52,9 @@ class AccessOperator
         o[ k1, k2 ]
       end
     when 2
-      k1 = coerce_numeric(keys[0], @semantic.keys[0], scope)
-      k2 = coerce_numeric(keys[1], @semantic.keys[1], scope)
-      [k1, k2].each_with_index { |k,i| bad_access_key_type(o, i, k, Integer) unless k.is_a?(Integer) }
+      k1 = Utils.to_n(keys[0])
+      k2 = Utils.to_n(keys[1])
+      [k1, k2].each_with_index { |k,i| bad_string_access_key_type(o, i, k.nil? ? keys[i] : k) unless k.is_a?(Integer) }
 
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos (negative is count from end)
       k2 = k2 < 0 ? o.length - k1 + k2 + 1 : k2  # abs length (negative k2 is length from pos to end count)
@@ -158,6 +162,18 @@ class AccessOperator
     Types::TypeFactory.sem_ver(*keys)
   end
 
+  def access_PTimestampType(o, scope, keys)
+    keys.flatten!
+    fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>0, :max => 2, :actual => keys.size) if keys.size > 2
+    Types::TypeFactory.timestamp(*keys)
+  end
+
+  def access_PTimespanType(o, scope, keys)
+    keys.flatten!
+    fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>0, :max => 2, :actual => keys.size) if keys.size > 2
+    Types::TypeFactory.timespan(*keys)
+  end
+
   def access_PTupleType(o, scope, keys)
     keys.flatten!
     if Types::TypeFactory.is_range_parameter?(keys[-2]) && Types::TypeFactory.is_range_parameter?(keys[-1])
@@ -172,6 +188,14 @@ class AccessOperator
   end
 
   def access_PCallableType(o, scope, keys)
+    if keys.size > 0 && keys[0].is_a?(Array)
+      unless keys.size == 2
+        fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>2, :max => 2, :actual => keys.size)
+      end
+      unless keys[1].is_a?(Types::PAnyType)
+        bad_type_specialization_key_type(o, 1, k, Types::PAnyType)
+      end
+    end
     Types::TypeFactory.callable(*keys)
   end
 
@@ -221,6 +245,13 @@ class AccessOperator
     })
   end
 
+  def bad_string_access_key_type(lhs, key_index, actual)
+    fail(Issues::BAD_STRING_SLICE_KEY_TYPE, @semantic.keys[key_index], {
+      :left_value => lhs,
+      :actual_type => bad_key_type_name(actual),
+    })
+  end
+
   def bad_key_type_name(actual)
     case actual
     when nil

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

@@ -1,5 +1,44 @@
 module Puppet::Pops
 module Evaluator
+  class Jumper < Exception
+    attr_reader :value
+    attr_reader :file
+    attr_reader :line
+    def initialize(value, file, line)
+      @value = value
+      @file = file
+      @line = line
+    end
+  end
+
+  class Next < Jumper
+    def initialize(value, file, line)
+      super
+    end
+  end
+
+  class Return < Jumper
+    def initialize(value, file, line)
+      super
+    end
+  end
+
+  class PuppetStopIteration < StopIteration
+    attr_reader :file
+    attr_reader :line
+    attr_reader :pos
+
+    def initialize(file, line, pos = nil)
+      @file = file
+      @line = line
+      @pos = pos
+    end
+
+    def message
+      "break() from context where this is illegal"
+    end
+  end
+
 # A Closure represents logic bound to a particular scope.
 # As long as the runtime (basically the scope implementation) has the behavior of Puppet 3x it is not
 # safe to return and later use this closure.
@@ -63,9 +102,15 @@ class Closure < CallableSignature
         args_hash = param_scope.to_hash
       end
       Types::TypeMismatchDescriber.validate_parameters(closure_name, params_struct, args_hash)
+      result = catch(:next) do
+        @evaluator.evaluate_block_with_bindings(closure_scope, args_hash, @model.body)
+      end
+      Types::TypeAsserter.assert_instance_of(nil, return_type, result) do
+        "value returned from #{closure_name}"
+      end
+    else
+      @evaluator.evaluate_block_with_bindings(closure_scope, args_hash, @model.body)
     end
-
-    @evaluator.evaluate_block_with_bindings(closure_scope, args_hash, @model.body)
   end
 
   def parameters
@@ -84,6 +129,10 @@ class Closure < CallableSignature
     @model.parameters.collect(&:name)
   end
 
+  def return_type
+    @return_type ||= create_return_type
+  end
+
   # @api public
   def type
     @callable ||= create_callable_type
@@ -122,6 +171,16 @@ class Closure < CallableSignature
     def enclosing_scope
       @enclosing_scope
     end
+
+    def call(*args)
+      # A return from an unnamed closure is treated as a return from the context evaluating
+      # calling this closure - that is, as if it was the return call itself.
+      #
+      jumper = catch(:return) do
+        return call_with_scope(enclosing_scope, args)
+      end
+      raise jumper
+    end
   end
 
   class Named < Closure
@@ -162,7 +221,12 @@ class Closure < CallableSignature
     end)
 
     if type.callable?(final_args)
-      @evaluator.evaluate_block_with_bindings(scope, variable_bindings, @model.body)
+      result = catch(:next) do
+        @evaluator.evaluate_block_with_bindings(scope, variable_bindings, @model.body)
+      end
+      Types::TypeAsserter.assert_instance_of(nil, return_type, result) do
+        "value returned from #{closure_name}"
+      end
     else
       raise ArgumentError, Types::TypeMismatchDescriber.describe_signatures(closure_name, [self], final_args)
     end
@@ -217,7 +281,8 @@ class Closure < CallableSignature
 
   def create_callable_type()
     types = []
-    range = [0, 0]
+    from = 0
+    to = 0
     in_optional_parameters = false
     closure_scope = enclosing_scope
 
@@ -232,15 +297,11 @@ class Closure < CallableSignature
         @evaluator.fail(Issues::REQUIRED_PARAMETER_AFTER_OPTIONAL, param, { :param_name => param.name })
       end
 
-      range[0] += param_range[0]
-      range[1] += param_range[1]
-    end
-
-    if range[1] == Float::INFINITY
-      range[1] = :default
+      from += param_range[0]
+      to += param_range[1]
     end
-
-    Types::TypeFactory.callable(*(types + range))
+    param_types = Types::PTupleType.new(types, Types::PIntegerType.new(from, to))
+    Types::PCallableType.new(param_types, nil, return_type)
   end
 
   def create_params_struct
@@ -257,6 +318,14 @@ class Closure < CallableSignature
     type_factory.struct(members)
   end
 
+  def create_return_type
+    if @model.return_type
+      @evaluator.evaluate(@model.return_type, @enclosing_scope)
+    else
+      Types::PAnyType::DEFAULT
+    end
+  end
+
   def create_param_type(param, closure_scope)
     type = if param.type_expr
              @evaluator.evaluate(param.type_expr, closure_scope)