bolt 0.11.0 → 0.12.0

data/vendored/puppet/lib/puppet/pops/parser/epp_support.rb

@@ -201,8 +201,6 @@ module EppSupport
           if s.end_with? "<%"
             @mode = :error
             @issue = Issues::EPP_UNBALANCED_EXPRESSION
-          else
-            mode = :epp
           end
           return s
 

data/vendored/puppet/lib/puppet/pops/parser/evaluating_parser.rb

@@ -80,7 +80,7 @@ class EvaluatingParser
   end
 
   def convert_to_3x(object, scope)
-    val = evaluator.convert(object, scope, nil)
+    evaluator.convert(object, scope, nil)
   end
 
   def validate(parse_result)

data/vendored/puppet/lib/puppet/pops/parser/interpolation_support.rb

@@ -221,7 +221,7 @@ module Puppet::Pops::Parser::InterpolationSupport
 
   def transform_to_variable(token)
     token_name = token[0]
-    if [:NUMBER, :NAME, :WORD].include?(token_name) || self.class::KEYWORD_NAMES[token_name]
+    if [:NUMBER, :NAME, :WORD].include?(token_name) || self.class::KEYWORD_NAMES[token_name] || @taskm_keywords[token_name]
       t = token[1]
       ta = t.token_array
       [:VARIABLE, self.class::TokenValue.new([:VARIABLE, ta[1], ta[2]], t.offset, t.locator)]

data/vendored/puppet/lib/puppet/pops/parser/lexer2.rb

@@ -143,31 +143,9 @@ class Lexer2
   KEYWORDS.each {|k,v| v[1].freeze; v.freeze }
   KEYWORDS.freeze
 
-  # We maintain two different tables of tokens for the constructs
-  # introduced by 'tasks & plans'. Which ones we use is decided in
-  # +initvars+; by selecting one or the other variant, we select whether we
-  # hit the --tasks code paths
-  TASK_MANAGEMENT_TOKENS = {
-    :with_tasks => {
-      'plan' => [:PLAN, 'plan',  4]
-    },
-    :without_tasks => {
-      'plan' => [:PLAN_R, 'plan',  4]
-    }
-  }
-
-  TASK_MANAGEMENT_TOKENS.each do |_, variant|
-    variant.each { |_,v| v[1].freeze; v.freeze }
-    variant.freeze
-  end
-  TASK_MANAGEMENT_TOKENS.freeze
-
   # Reverse lookup of keyword name to string
   KEYWORD_NAMES = {}
   KEYWORDS.each {|k, v| KEYWORD_NAMES[v[0]] = k }
-  TASK_MANAGEMENT_TOKENS.each do |_, variant|
-    variant.each { |k,v| KEYWORD_NAMES[v[0]] = k }
-  end
   KEYWORD_NAMES.freeze
 
   PATTERN_WS        = %r{[[:blank:]\r]+}
@@ -535,7 +513,6 @@ class Lexer2
             scn.pos = before
             invalid_number = scn.peek(after - before) unless invalid_number
           end
-          length = scn.pos - before
           assert_numeric(invalid_number, before)
           scn.pos = before + 1
           lex_error(Issues::ILLEGAL_NUMBER, {:value => invalid_number})
@@ -545,7 +522,6 @@ class Lexer2
     ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
       'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '_'].each do |c|
       @selector[c] = lambda do
-
         scn = @scanner
         before = scn.pos
         value = scn.scan(PATTERN_BARE_WORD)
@@ -685,8 +661,8 @@ class Lexer2
       :after => nil,
       :line_lexical_start => 0
     }
-    taskm_mode = Puppet[:tasks] ? :with_tasks : :without_tasks
-    @taskm_keywords = TASK_MANAGEMENT_TOKENS[taskm_mode]
+    # Use of --tasks introduces the new keyword 'plan'
+    @taskm_keywords = Puppet[:tasks] ? { 'plan' => [:PLAN, 'plan',  4] }.freeze : EMPTY_HASH
   end
 
   # Scans all of the content and returns it in an array

data/vendored/puppet/lib/puppet/pops/parser/locator.rb

@@ -164,8 +164,6 @@ class Locator
   class AbstractLocator < Locator
     attr_accessor :line_index
     attr_accessor :string
-    attr_accessor :prev_offset
-    attr_accessor :prev_line
     attr_reader   :string
     attr_reader   :file
 
@@ -255,19 +253,19 @@ class Locator
 
     # Returns the line number (first line is 1) for the given offset
     def line_for_offset(offset)
-      if prev_offset == offset
+      if @prev_offset == offset
         # use cache
-        return prev_line
+        return @prev_line
       end
       if line_nbr = ary_bsearch_i(line_index, offset)
         # cache
-        prev_offset = offset
-        prev_line = line_nbr
+        @prev_offset = offset
+        @prev_line = line_nbr
         return line_nbr
       end
       # If not found it is after last
       # clear cache
-      prev_offset = prev_line = nil
+      @prev_offset = @prev_line = nil
       return line_index.size
     end
   end

data/vendored/puppet/lib/puppet/pops/parser/parser_support.rb

@@ -121,7 +121,7 @@ class Parser
       file = lexer.file
     end
     file = nil unless file.is_a?(String) && !file.empty?
-    raise Puppet::ParseErrorWithIssue.new(error, file, line, pos, nil, issue_code = Issues::SYNTAX_ERROR.issue_code)
+    raise Puppet::ParseErrorWithIssue.new(error, file, line, pos, nil, Issues::SYNTAX_ERROR.issue_code)
   end
 
   # Parses a String of pp DSL code.
@@ -219,7 +219,7 @@ class Parser
     # Create a synthetic NOOP token at EOF offset with 0 size. The lexer does not produce an EOF token that is
     # visible to the grammar rules. Creating this token is mainly to reuse the positioning logic as it
     # expects a token decorated with location information.
-    token_sym, token = @lexer.emit_completed([:NOOP,'',0], locator.string.bytesize)
+    _, token = @lexer.emit_completed([:NOOP,'',0], locator.string.bytesize)
     loc(no_op, token)
     # Program with a Noop
     program = Factory.PROGRAM(no_op, [], locator)

data/vendored/puppet/lib/puppet/pops/parser/slurp_support.rb

@@ -45,9 +45,6 @@ module SlurpSupport
    # Copy from old lexer - can do much better
    def slurp_uqstring
      scn = @scanner
-     last = scn.matched
-     ignore = true
-
      str = slurp(scn, @lexing_context[:uq_slurp_pattern], @lexing_context[:escapes], :ignore_invalid_escapes)
 
      # Terminator may be a single char '$', two characters '${', or empty string '' at the end of intput.

data/vendored/puppet/lib/puppet/pops/pcore.rb

@@ -40,17 +40,6 @@ module Pcore
     add_alias('Pcore::QRef', TYPE_QUALIFIED_REFERENCE, loader)
 
     if Puppet[:tasks]
-      require_relative 'types/execution_result'
-
-      add_object_type('Target', <<-PUPPET, loader)
-      {
-        attributes => {
-          host => String[1],
-          options => { type => Hash[String[1], Data], value => {} }
-        }
-      }
-      PUPPET
-
       add_object_type('Task', <<-PUPPET, loader)
         {
           attributes => {   

data/vendored/puppet/lib/puppet/pops/serialization/object.rb

@@ -9,8 +9,7 @@ module Serialization
 class ObjectReader
   include InstanceReader
 
-  def read(impl_class, value_count, deserializer)
-    type = impl_class._pcore_type
+  def read(type, impl_class, value_count, deserializer)
     (names, types, required_count) = type.parameter_info(impl_class)
     max = names.size
     unless value_count >= required_count && value_count <= max
@@ -25,7 +24,7 @@ class ObjectReader
         Types::TypeAsserter.assert_instance_of(nil, ptype, arg) { "#{type.name}[#{names[index]}]" } unless arg == :default
       else
         attr = type[names[index]]
-        raise Serialization::SerializationError, _("Missing default value for %{type_name}[%{name}]") % { type_name: type.name, name: names[index] } unless attr.value?
+        raise Serialization::SerializationError, _("Missing default value for %{type_name}[%{name}]") % { type_name: type.name, name: names[index] } unless attr && attr.value?
         args << attr.value
       end
     end
@@ -43,7 +42,7 @@ class ObjectWriter
 
   def write(type, value, serializer)
     impl_class = value.class
-    (names, types, required_count) = type.parameter_info(impl_class)
+    (names, _, required_count) = type.parameter_info(impl_class)
     args = names.map { |name| value.send(name) }
 
     # Pop optional arguments that are default

data/vendored/puppet/lib/puppet/pops/serialization/to_data_converter.rb

@@ -252,7 +252,7 @@ module Serialization
           end
         else
           process(value) do
-            (names, types, required_count) = pcore_type.parameter_info(value.class)
+            (names, _, required_count) = pcore_type.parameter_info(value.class)
             args = names.map { |name| value.send(name) }
 
             # Pop optional arguments that are default

data/vendored/puppet/lib/puppet/pops/time/timespan.rb

@@ -259,7 +259,7 @@ module Time
           add_unless_zero(result, KEY_NANOSECONDS, n % 1000)
           n /= 1000
           add_unless_zero(result, KEY_MICROSECONDS, n % 1000)
-          add_unless_zero(result, KEY_MILLISECONDS, n /= 1000)
+          add_unless_zero(result, KEY_MILLISECONDS, n / 1000)
         end
         result[KEY_NEGATIVE] = true if negative?
       end

data/vendored/puppet/lib/puppet/pops/types/iterable.rb

@@ -48,10 +48,11 @@ module Puppet::Pops::Types
     # The value `nil` is returned for all other objects.
     #
     # @param o [Object] The object to produce an `Iterable` for
+    # @param element_type [PAnyType] the element type for the iterator. Optional (inferred if not provided)
     # @return [Iterable,nil] The produced `Iterable` or `nil` if it couldn't be produced
     #
     # @api public
-    def self.on(o)
+    def self.on(o, element_type = nil)
       case o
       when IteratorProducer
         o.iterator
@@ -63,18 +64,24 @@ module Puppet::Pops::Types
         if o.empty?
           Iterator.new(PUnitType::DEFAULT, o.each)
         else
-          tc = TypeCalculator.singleton
-          Iterator.new(PVariantType.maybe_create(o.map {|e| tc.infer_set(e) }), o.each)
+          if element_type.nil?
+            tc = TypeCalculator.singleton
+            element_type = PVariantType.maybe_create(o.map {|e| tc.infer_set(e) })
+          end
+          Iterator.new(element_type, o.each)
         end
       when Hash
         # Each element is a two element [key, value] tuple.
         if o.empty?
           HashIterator.new(PHashType::DEFAULT_KEY_PAIR_TUPLE, o.each)
         else
-          tc = TypeCalculator.singleton
-          HashIterator.new(PTupleType.new([
-            PVariantType.maybe_create(o.keys.map {|e| tc.infer_set(e) }),
-            PVariantType.maybe_create(o.values.map {|e| tc.infer_set(e) })], PHashType::KEY_PAIR_TUPLE_SIZE), o.each_pair)
+          if element_type.nil?
+            tc = TypeCalculator.singleton
+            element_type = PTupleType.new([
+              PVariantType.maybe_create(o.keys.map {|e| tc.infer_set(e) }),
+              PVariantType.maybe_create(o.values.map {|e| tc.infer_set(e) })], PHashType::KEY_PAIR_TUPLE_SIZE)
+          end
+          HashIterator.new(element_type, o.each_pair)
         end
       when Integer
         if o == 0

data/vendored/puppet/lib/puppet/pops/types/p_object_type.rb

@@ -457,7 +457,7 @@ class PObjectType < PMetaType
   # @return [Object] the created instance
   # @api private
   def read(value_count, deserializer)
-    reader.read(implementation_class, value_count, deserializer)
+    reader.read(self, implementation_class, value_count, deserializer)
   end
 
   # Write an instance of this type using a serializer
@@ -471,15 +471,11 @@ class PObjectType < PMetaType
     # @api private
   def create_new_function
     impl_class = implementation_class
-    class_name = impl_class.name || "Anonymous Ruby class for #{name}"
 
     (param_names, param_types, required_param_count) = parameter_info(impl_class)
 
     # Create the callable with a size that reflects the required and optional parameters
-    param_types << required_param_count
-    param_types << param_names.size
-
-    create_type = TypeFactory.callable(*param_types)
+    create_type = TypeFactory.callable(*param_types, required_param_count, param_names.size)
     from_hash_type = TypeFactory.callable(init_hash_type, 1, 1)
 
     # Create and return a #new_XXX function where the dispatchers are added programmatically.
@@ -527,6 +523,7 @@ class PObjectType < PMetaType
       if impl_name.nil?
         # Use generator to create a default implementation
         @implementation_class = RubyGenerator.new.create_class(self)
+        @implementation_class.class_eval(&@implementation_override) if instance_variable_defined?(:@implementation_override)
       else
         # Can the mapping be loaded?
         class_name = impl_name[0]
@@ -547,10 +544,42 @@ class PObjectType < PMetaType
     @implementation_class = cls
   end
 
+  # The block passed to this method will be passed in a call to `#class_eval` on the dynamically generated
+  # class for this data type. It's indended use is to complement or redefine the generated methods and
+  # attribute readers.
+  #
+  # The method is normally called with the block passed to `#implementation` when a data type is defined using
+  # {Puppet::DataTypes::create_type}.
+  #
+  # @api private
+  def implementation_override=(block)
+    if !@implementation_class.nil? || instance_variable_defined?(:@implementation_override)
+      raise ArgumentError, "attempt to redefine implementation override for #{label}"
+    end
+    @implementation_override = block
+  end
+
+  def extract_init_hash(o)
+    return o._pcore_init_hash if o.respond_to?(:_pcore_init_hash)
+
+    result = {}
+    pic = parameter_info(o.class)
+    attrs = attributes(true)
+    pic[0].each do |name|
+      v = o.send(name)
+      result[name] = v unless attrs[name].default_value?(v)
+    end
+    result
+  end
+
   # @api private
   # @return [(Array<String>, Array<PAnyType>, Integer)] array of parameter names, array of parameter types, and a count reflecting the required number of parameters
   def parameter_info(impl_class)
     # Create a types and a names array where optional entries ends up last
+    @parameter_info ||= {}
+    pic = @parameter_info[impl_class]
+    return pic if pic
+
     opt_types = []
     opt_names = []
     non_opt_types = []
@@ -602,7 +631,9 @@ class PObjectType < PMetaType
       end
     end
 
-    [param_names, param_types, non_opt_types.size]
+    pic = [param_names.freeze, param_types.freeze, non_opt_types.size].freeze
+    @parameter_info[impl_class] = pic
+    pic
   end
 
   # @api private

data/vendored/puppet/lib/puppet/pops/types/p_object_type_extension.rb

@@ -28,6 +28,23 @@ class PObjectTypeExtension < PAnyType
     impl_class.new(base_type, init_parameters)
   end
 
+  # Creates an array of type parameters from the attributes of the given instance that matches the
+  # type parameters by name. Type parameters for which there is no matching attribute
+  # will have `nil` in their corresponding position on the array. The array is then passed
+  # as the `init_parameters` argument in a call to `create`
+  #
+  # @return [PObjectTypeExtension] the created extension
+  # @api private
+  def self.create_from_instance(base_type, instance)
+    type_parameters = base_type.type_parameters(true)
+    attrs = base_type.attributes(true)
+    params = type_parameters.keys.map do |pn|
+      attr = attrs[pn]
+      attr.nil? ? nil : instance.send(pn)
+    end
+    create(base_type, params)
+  end
+
   def [](name)
     @base_type[name]
   end
@@ -38,15 +55,10 @@ class PObjectTypeExtension < PAnyType
     raise Puppet::ParseError, _('The %{label}-Type cannot be parameterized using []') % { label: base_type.label } if pts.empty?
     @base_type = base_type
 
-    named_args = false
-    if init_parameters.is_a?(PuppetObject)
-      init_parameters = parameters_from_instance(init_parameters, pts)
-    else
-      named_args = init_parameters.size == 1 && init_parameters[0].is_a?(Hash)
-      if named_args
-        # Catch case when first parameter is an assignable Hash
-        named_args = pts.size >= 1 && !pts.values[0].type.instance?(init_parameters[0])
-      end
+    named_args = init_parameters.size == 1 && init_parameters[0].is_a?(Hash)
+    if named_args
+      # Catch case when first parameter is an assignable Hash
+      named_args = pts.size >= 1 && !pts.values[0].type.instance?(init_parameters[0])
     end
 
     by_name = {}
@@ -143,19 +155,6 @@ class PObjectTypeExtension < PAnyType
 
   protected
 
-  # Creates an array of type parameters from the attributes that matches the
-  # type parameters by name. Type parameters for which there is no matching attribute
-  # will have `nil` in their corresponding position on the array.
-  #
-  # @return [Array] array of values from instance that maps to type parameters
-  def parameters_from_instance(instance, type_parameters)
-    attrs = @base_type.attributes(true)
-    type_parameters.keys.map do |pn|
-      attr = attrs[pn]
-      attr.nil? ? nil : instance.send(pn)
-    end
-  end
-
   # Checks that the given `param_values` hash contains all keys present in the `parameters` of
   # this instance and that each keyed value is a match for the given parameter. The match is done
   # using case expression semantics.

data/vendored/puppet/lib/puppet/pops/types/p_sem_ver_range_type.rb

@@ -107,7 +107,6 @@ class PSemVerRangeType < PAnyType
   end
 
   def self.new_function(type)
-    range_expr = "\\A#{range_pattern}\\Z"
     @new_function ||= Puppet::Functions.create_loaded_function(:new_VersionRange, type.loader) do
       local_types do
         type 'SemVerRangeString = String[1]'

data/vendored/puppet/lib/puppet/pops/types/p_type_set_type.rb

@@ -227,7 +227,6 @@ class PTypeSetType < PMetaType
   def name_for(t, default_name)
     key = @types.key(t)
     if key.nil?
-      qname = t.name
       if @references.empty?
         default_name
       else

data/vendored/puppet/lib/puppet/pops/types/p_uri_type.rb

@@ -151,7 +151,6 @@ class PURIType < PAnyType
   def _assignable?(o, guard = nil)
     return false unless o.class == self.class
     return true if @parameters.nil?
-    params = @parameters
     o_params = o.parameters || EMPTY_HASH
 
     eval = Parser::EvaluatingParser.singleton.evaluator

data/vendored/puppet/lib/puppet/pops/types/puppet_object.rb

@@ -15,7 +15,7 @@ module PuppetObject
         # Create a parameterized type based on the values of this instance that
         # contains a parameter value for each type parameter that matches an
         # attribute by name and type of value
-        @_cached_ptype = PObjectTypeExtension.create(t, self)
+        @_cached_ptype = PObjectTypeExtension.create_from_instance(t, self)
       end
       t = @_cached_ptype
     end