bolt 0.19.1 → 0.20.0

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

@@ -1,127 +0,0 @@
-module Puppet::Pops
-module Serialization
-module JsonPath
-  # Creates a _json_path_ reference from the given `path` argument
-  #
-  # @path path [Array<Integer,String>] An array of integers and strings
-  # @return [String] the created json_path
-  #
-  # @api private
-  def self.to_json_path(path)
-    p = '$'
-    path.each do |seg|
-      if seg.nil?
-        p << '[null]'
-      elsif Types::PScalarDataType::DEFAULT.instance?(seg)
-        p << '[' << Types::StringConverter.singleton.convert(seg, '%p') << ']'
-      else
-        # Unable to construct json path from complex segments
-        return nil
-      end
-    end
-    p
-  end
-
-  # Resolver for JSON path that uses the Puppet parser to create the AST. The path must start
-  # with '$' which denotes the value that is passed into the parser. This parser can easily
-  # be extended with more elaborate resolution mechanisms involving document sets.
-  #
-  # The parser is limited to constructs generated by the {JsonPath#to_json_path}
-  # method.
-  #
-  # @api private
-  class Resolver
-    def self.singleton
-      @singleton ||= self.new
-    end
-
-    def initialize
-      @parser = Parser::Parser.new
-      @visitor = Visitor.new(nil, 'resolve', 2, 2)
-    end
-
-    # Resolve the given _path_ in the given _context_.
-    # @param context [Object] the context used for resolution
-    # @param path [String] the json path
-    # @return [Object] the resolved value
-    #
-    def resolve(context, path)
-      factory = @parser.parse_string(path)
-      v = resolve_any(factory.model.body, context, path)
-      v.is_a?(Builder) ? v.resolve : v
-    end
-
-    def resolve_any(ast, context, path)
-      @visitor.visit_this_2(self, ast, context, path)
-    end
-
-    def resolve_AccessExpression(ast, context, path)
-      bad_json_path(path) unless ast.keys.size == 1
-      receiver = resolve_any(ast.left_expr, context, path)
-      key = resolve_any(ast.keys[0], context, path)
-      if receiver.is_a?(Types::PuppetObject)
-        PCORE_TYPE_KEY == key ? receiver._pcore_type : receiver.send(key)
-      else
-        receiver[key]
-      end
-    end
-
-    def resolve_NamedAccessExpression(ast, context, path)
-      receiver = resolve_any(ast.left_expr, context, path)
-      key = resolve_any(ast.right_expr, context, path)
-      if receiver.is_a?(Types::PuppetObject)
-        PCORE_TYPE_KEY == key ? receiver._pcore_type : receiver.send(key)
-      else
-        receiver[key]
-      end
-    end
-
-    def resolve_QualifiedName(ast, _, _)
-      v = ast.value
-      'null' == v ? nil : v
-    end
-
-    def resolve_QualifiedReference(ast, _, _)
-      v = ast.cased_value
-      'null'.casecmp(v) == 0 ? nil : v
-    end
-
-    def resolve_ReservedWord(ast, _, _)
-      ast.word
-    end
-
-    def resolve_LiteralUndef(_, _, _)
-      'undef'
-    end
-
-    def resolve_LiteralDefault(_, _, _)
-      'default'
-    end
-
-    def resolve_VariableExpression(ast, context, path)
-      # A single '$' means root, i.e. the context.
-      bad_json_path(path) unless EMPTY_STRING == resolve_any(ast.expr, context, path)
-      context
-    end
-
-    def resolve_CallMethodExpression(ast, context, path)
-      bad_json_path(path) unless ast.arguments.empty?
-      resolve_any(ast.functor_expr, context, path)
-    end
-
-    def resolve_LiteralValue(ast, _, _)
-      ast.value
-    end
-
-    def resolve_Object(ast, _, path)
-      bad_json_path(path)
-    end
-
-    def bad_json_path(path)
-      raise SerializationError, _('Unable to parse jsonpath "%{path}"') % { :path => path }
-    end
-    private :bad_json_path
-  end
-end
-end
-end

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

@@ -1,70 +0,0 @@
-require_relative 'instance_reader'
-require_relative 'instance_writer'
-
-module Puppet::Pops
-module Serialization
-
-# Instance reader for objects that implement {Types::PuppetObject}
-# @api private
-class ObjectReader
-  include InstanceReader
-
-  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
-      raise Serialization::SerializationError, _("Feature count mismatch for %{value0}. Expected %{required_count} - %{max}, actual %{value_count}") % { value0: impl_class.name, required_count: required_count, max: max, value_count: value_count }
-    end
-    # Deserializer must know about this instance before we read its attributes
-    val = deserializer.remember(impl_class.allocate)
-    args = Array.new(value_count) { deserializer.read }
-    types.each_with_index do |ptype, index|
-      if index < args.size
-        arg = args[index]
-        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 && attr.value?
-        args << attr.value
-      end
-    end
-    val.send(:initialize, *args)
-    val
-  end
-
-  INSTANCE = ObjectReader.new
-end
-
-# Instance writer for objects that implement {Types::PuppetObject}
-# @api private
-class ObjectWriter
-  include InstanceWriter
-
-  def write(type, value, serializer)
-    impl_class = value.class
-    (names, _, required_count) = type.parameter_info(impl_class)
-    args = names.map { |name| value.send(name) }
-
-    # Pop optional arguments that are default
-    while args.size > required_count
-      break unless type[names[args.size-1]].default_value?(args.last)
-      args.pop
-    end
-
-    if type.name.start_with?('Pcore::') || serializer.type_by_reference?
-      serializer.push_written(value)
-      serializer.start_pcore_object(type.name, args.size)
-    else
-      serializer.start_object(args.size + 1)
-      serializer.write(type)
-      serializer.push_written(value)
-    end
-
-    args.each { |arg| serializer.write(arg) }
-  end
-
-  INSTANCE = ObjectWriter.new
-end
-end
-end
-

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

@@ -1,140 +0,0 @@
-require_relative 'extension'
-
-module Puppet::Pops
-module Serialization
-  # The serializer is capable of writing, arrays, maps, and complex objects using an underlying protocol writer. It takes care of
-  # tabulating and disassembling complex objects.
-  # @api public
-  class Serializer
-    # Provides access to the writer.
-    # @api private
-    attr_reader :writer
-
-    # @param writer [AbstractWriter] the writer that is used for writing primitive values
-    # @param options [{String, Object}] serialization options
-    # @option options [Boolean] :type_by_reference `true` if Object types are serialized by name only.
-    # @api public
-    def initialize(writer, options = EMPTY_HASH)
-      @written = {}
-      @writer = writer
-      @options = options
-    end
-
-    # Tell the underlying writer to finish
-    # @api public
-    def finish
-      @writer.finish
-    end
-
-    # Write an object
-    # @param [Object] value the object to write
-    # @api public
-    def write(value)
-      case value
-      when Integer, Float, String, true, false, nil
-        @writer.write(value)
-      when :default
-        @writer.write(Extension::Default::INSTANCE)
-      else
-        index = @written[value.object_id]
-        if index.nil?
-          write_tabulated_first_time(value)
-        else
-          @writer.write(Extension::Tabulation.new(index))
-        end
-      end
-    end
-
-    # Write the start of an array.
-    # @param [Integer] size the size of the array
-    # @api private
-    def start_array(size)
-      @writer.write(Extension::ArrayStart.new(size))
-    end
-
-    # Write the start of a map (hash).
-    # @param [Integer] size the number of entries in the map
-    # @api private
-    def start_map(size)
-      @writer.write(Extension::MapStart.new(size))
-    end
-
-    # Write the start of a complex pcore object
-    # @param [String] type_ref the name of the type
-    # @param [Integer] attr_count the number of attributes in the object
-    # @api private
-    def start_pcore_object(type_ref, attr_count)
-      @writer.write(Extension::PcoreObjectStart.new(type_ref, attr_count))
-    end
-
-    # Write the start of a complex object
-    # @param [Integer] attr_count the number of attributes in the object
-    # @api private
-    def start_object(attr_count)
-      @writer.write(Extension::ObjectStart.new(attr_count))
-    end
-
-    def push_written(value)
-      @written[value.object_id] = @written.size
-    end
-
-    # Write the start of a sensitive object
-    # @api private
-    def start_sensitive
-      @writer.write(Extension::SensitiveStart::INSTANCE)
-    end
-
-    def type_by_reference?
-      @options[:type_by_reference] == true
-    end
-
-    def to_s
-      "#{self.class.name} with #{@writer}"
-    end
-
-    def inspect
-      to_s
-    end
-
-    # First time write of a tabulated object. This means that the object is written and then remembered. Subsequent writes
-    # of the same object will yield a write of a tabulation index instead.
-    # @param [Object] value the value to write
-    # @api private
-    def write_tabulated_first_time(value)
-      case
-      when value.instance_of?(Symbol),
-          value.instance_of?(Regexp),
-          value.instance_of?(SemanticPuppet::Version),
-          value.instance_of?(SemanticPuppet::VersionRange),
-          value.instance_of?(Time::Timestamp),
-          value.instance_of?(Time::Timespan),
-          value.instance_of?(Types::PBinaryType::Binary),
-          value.is_a?(URI)
-        push_written(value)
-        @writer.write(value)
-      when value.instance_of?(Array)
-        push_written(value)
-        start_array(value.size)
-        value.each { |elem| write(elem) }
-      when value.instance_of?(Hash)
-        push_written(value)
-        start_map(value.size)
-        value.each_pair { |key, val| write(key); write(val) }
-      when value.instance_of?(Types::PSensitiveType::Sensitive)
-        start_sensitive
-        write(value.unwrap)
-      when value.instance_of?(Types::PTypeReferenceType)
-        push_written(value)
-        @writer.write(value)
-      when value.is_a?(Types::PuppetObject)
-        value._pcore_type.write(value, self)
-      else
-        impl_class = value.class
-        type = Loaders.implementation_registry.type_for_module(impl_class)
-        raise SerializationError, _("No Puppet Type found for %{klass}") % { klass: impl_class.name } unless type.is_a?(Types::PObjectType)
-        type.write(value, self)
-      end
-    end
-  end
-end
-end

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

@@ -1,67 +0,0 @@
-module Puppet::Pops
-module Serialization
-  # Implements all the constructors found in the Time class and ensures that
-  # the created Time object can be serialized and deserialized using its
-  # seconds and nanoseconds without loss of precision.
-  #
-  # @deprecated No longer in use. Functionality replaced by Timestamp
-  # @api private
-  class TimeFactory
-
-    NANO_DENOMINATOR = 10**9
-
-    def self.at(*args)
-      sec_nsec_safe(Time.at(*args))
-    end
-
-    def self.gm(*args)
-      sec_nsec_safe(Time.gm(*args))
-    end
-
-    def self.local(*args)
-      sec_nsec_safe(Time.local(*args))
-    end
-
-    def self.mktime(*args)
-      sec_nsec_safe(Time.mktime(*args))
-    end
-
-    def self.new(*args)
-      sec_nsec_safe(Time.new(*args))
-    end
-
-    def self.now
-      sec_nsec_safe(Time.now)
-    end
-
-    def self.utc(*args)
-      sec_nsec_safe(Time.utc(*args))
-    end
-
-    # Creates a Time object from a Rational defined as:
-    #
-    # (_sec_ * #NANO_DENOMINATOR + _nsec_) / #NANO_DENOMINATOR
-    #
-    # This ensures that a Time object can be reliably serialized and using its
-    # its #tv_sec and #tv_nsec values and then recreated again (using this method)
-    # without loss of precision.
-    #
-    # @param sec [Integer] seconds since Epoch
-    # @param nsec [Integer] nano seconds
-    # @return [Time] the created object
-    #
-    def self.from_sec_nsec(sec, nsec)
-      Time.at(Rational(sec * NANO_DENOMINATOR + nsec, NANO_DENOMINATOR))
-    end
-
-    # Returns a new Time object that is adjusted to ensure that precision is not
-    # lost when it is serialized and deserialized using its seconds and nanoseconds
-    # @param t [Time] the object to adjust
-    # @return [Time] the adjusted object
-    #
-    def self.sec_nsec_safe(t)
-      from_sec_nsec(t.tv_sec, t.tv_nsec)
-    end
-  end
-end
-end

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

@@ -1,305 +0,0 @@
-module Puppet::Pops
-module Serialization
-  # Class that can process an arbitrary object into a value that is assignable to `Data`.
-  #
-  # @api public
-  class ToDataConverter
-    include Evaluator::Runtime3Support
-
-    # Convert the given _value_ according to the given _options_ and return the result of the conversion
-    #
-    # @param value [Object] the value to convert
-    # @param options {Symbol => <Boolean,String>} options hash
-    # @option options [Boolean] :rich_data `true` if rich data is enabled
-    # @option options [Boolean] :local_references use local references instead of duplicating complex entries
-    # @option options [Boolean] :type_by_reference `true` if Object types are converted to references rather than embedded.
-    # @option options [Boolean] :symbol_as_string `true` if Symbols should be converted to strings (with type loss)
-    # @option options [String] :path_prefix String to prepend to path in warnings and errors
-    # @return [Data] the processed result. An object assignable to `Data`.
-    #
-    # @api public
-    def self.convert(value, options = EMPTY_HASH)
-      new(options).convert(value)
-    end
-
-    # Create a new instance of the processor
-    #
-    # @param options {Symbol => Object} options hash
-    # @option options [Boolean] :rich_data `true` if rich data is enabled
-    # @option options [Boolean] :local_references use local references instead of duplicating complex entries
-    # @option options [Boolean] :type_by_reference `true` if Object types are converted to references rather than embedded.
-    # @option options [Boolean] :symbol_as_string `true` if Symbols should be converted to strings (with type loss)
-    # @option options [String] :message_prefix String to prepend to path in warnings and errors
-    # @option semantic [Object] :semantic object to pass to the issue reporter
-    def initialize(options = EMPTY_HASH)
-      @type_by_reference = options[:type_by_reference]
-      @type_by_reference = true if @type_by_reference.nil?
-
-      @local_reference = options[:local_reference]
-      @local_reference = true if @local_reference.nil?
-
-      @symbol_as_string = options[:symbol_as_string]
-      @symbol_as_string = false if @symbol_as_string.nil?
-
-      @rich_data = options[:rich_data]
-      @rich_data = false if @rich_data.nil?
-
-      @message_prefix = options[:message_prefix]
-      @semantic = options[:semantic]
-    end
-
-    # Convert the given _value_
-    #
-    # @param value [Object] the value to convert
-    # @return [Data] the processed result. An object assignable to `Data`.
-    #
-    # @api public
-    def convert(value)
-      @path = []
-      @values = {}
-      to_data(value)
-    end
-
-    private
-
-    def path_to_s
-      s = @message_prefix || ''
-      s << JsonPath.to_json_path(@path)[1..-1]
-      s
-    end
-
-    def to_data(value)
-      if value.nil? || Types::PScalarDataType::DEFAULT.instance?(value)
-        value
-      elsif :default == value
-        if @rich_data
-          { PCORE_TYPE_KEY => PCORE_TYPE_DEFAULT }
-        else
-          serialization_issue(Issues::SERIALIZATION_DEFAULT_CONVERTED_TO_STRING, :path => path_to_s)
-          'default'
-        end
-      elsif value.is_a?(Symbol)
-        if @symbol_as_string
-          value.to_s
-        elsif @rich_data
-          { PCORE_TYPE_KEY => PCORE_TYPE_SYMBOL, PCORE_VALUE_KEY => value.to_s }
-        else
-          unknown_to_string_with_warning(value)
-        end
-      elsif value.instance_of?(Array)
-        process(value) do
-          result = []
-          value.each_with_index do |elem, index|
-            with(index) { result << to_data(elem) }
-          end
-          result
-        end
-      elsif value.instance_of?(Hash)
-        process(value) do
-          if value.keys.all? { |key| key.is_a?(String) }
-            result = {}
-            value.each_pair { |key, elem| with(key) { result[key] = to_data(elem) } }
-            result
-          else
-            non_string_keyed_hash_to_data(value)
-          end
-        end
-      elsif value.instance_of?(Types::PSensitiveType::Sensitive)
-        process(value) do
-          { PCORE_TYPE_KEY => PCORE_TYPE_SENSITIVE, PCORE_VALUE_KEY => to_data(value.unwrap) }
-        end
-      else
-        unknown_to_data(value)
-      end
-    end
-
-    # If `:local_references` is enabled, then the `object_id` will be associated with the current _path_ of
-    # the context the first time this method is called. The method then returns the result of  yielding to
-    # the given block. Subsequent calls with a value that has the same `object_id` will instead return a
-    # reference based on the given path.
-    #
-    # If `:local_references` is disabled, then this method performs a check for endless recursion before
-    # it yields to the given block. The result of yielding is returned.
-    #
-    # @param value [Object] the value
-    # @yield The block that will produce the data for the value
-    # @return [Data] the result of yielding to the given block, or a hash denoting a reference
-    #
-    # @api private
-    def process(value, &block)
-      if @local_reference
-        id = value.object_id
-        ref = @values[id]
-        if ref.nil?
-          @values[id] = @path.dup
-          yield
-        elsif ref.instance_of?(Hash)
-          ref
-        else
-          json_ref = JsonPath.to_json_path(ref)
-          if json_ref.nil?
-            # Complex key and hence no way to reference the prior value. The value must therefore be
-            # duplicated which in turn introduces a risk for endless recursion in case of self
-            # referencing structures
-            with_recursive_guard(value, &block)
-          else
-            @values[id] = { PCORE_TYPE_KEY => PCORE_LOCAL_REF_SYMBOL, PCORE_VALUE_KEY => json_ref }
-          end
-        end
-      else
-        with_recursive_guard(value, &block)
-      end
-    end
-
-    # Pushes `key` to the end of the path and yields to the given block. The
-    # `key` is popped when the yield returns.
-    # @param key [Object] the key to push on the current path
-    # @yield The block that will produce the returned value
-    # @return [Object] the result of yielding to the given block
-    #
-    # @api private
-    def with(key)
-      @path.push(key)
-      value = yield
-      @path.pop
-      value
-    end
-
-    # @param value [Object] the value to use when checking endless recursion
-    # @yield The block that will produce the data
-    # @return [Data] the result of yielding to the given block
-    def with_recursive_guard(value)
-      id = value.object_id
-      if @recursive_lock
-        if @recursive_lock.include?(id)
-          serialization_issue(Issues::SERIALIZATION_ENDLESS_RECURSION, :type_name => value.class.name)
-        end
-        @recursive_lock[id] = true
-      else
-        @recursive_lock = { id => true }
-      end
-      v = yield
-      @recursive_lock.delete(id)
-      v
-    end
-
-    def unknown_to_data(value)
-      @rich_data ? value_to_data_hash(value) : unknown_to_string_with_warning(value)
-    end
-
-    def unknown_key_to_string_with_warning(value)
-      str = unknown_to_string(value)
-      serialization_issue(Issues::SERIALIZATION_UNKNOWN_KEY_CONVERTED_TO_STRING, :path => path_to_s, :klass => value.class, :value => str)
-      str
-    end
-
-    def unknown_to_string_with_warning(value)
-      str = unknown_to_string(value)
-      serialization_issue(Issues::SERIALIZATION_UNKNOWN_CONVERTED_TO_STRING, :path => path_to_s, :klass => value.class, :value => str)
-      str
-    end
-
-    def unknown_to_string(value)
-      value.is_a?(Regexp) ? Puppet::Pops::Types::PRegexpType.regexp_to_s_with_delimiters(value) : value.to_s
-    end
-
-    def non_string_keyed_hash_to_data(hash)
-      if @rich_data
-        to_key_extended_hash(hash)
-      else
-        result = {}
-        hash.each_pair do |key, value|
-          if key.is_a?(Symbol) && @symbol_as_string
-            key = key.to_s
-          elsif !key.is_a?(String)
-            key = unknown_key_to_string_with_warning(key)
-          end
-          with(key) { result[key] = to_data(value) }
-        end
-        result
-      end
-    end
-
-    # A Key extended hash is a hash whose keys are not entirely strings. Such a hash
-    # cannot be safely represented as JSON or YAML
-    #
-    # @param hash {Object => Object} the hash to process
-    # @return [String => Data] the representation of the extended hash
-    def to_key_extended_hash(hash)
-      key_value_pairs = []
-      hash.each_pair do |key, value|
-        key = to_data(key)
-        key_value_pairs << key
-        key_value_pairs << with(key) { to_data(value) }
-      end
-      { PCORE_TYPE_KEY => PCORE_TYPE_HASH, PCORE_VALUE_KEY => key_value_pairs }
-    end
-
-    def value_to_data_hash(value)
-      pcore_type = value.is_a?(Types::PuppetObject) ? value._pcore_type : Types::TypeCalculator.singleton.infer(value)
-      if pcore_type.is_a?(Puppet::Pops::Types::PRuntimeType)
-        unknown_to_string_with_warning(value)
-      else
-        pcore_tv = pcore_type_to_data(pcore_type)
-        if pcore_type.roundtrip_with_string?
-          {
-            PCORE_TYPE_KEY => pcore_tv,
-
-            # Scalar values are stored using their default string representation
-            PCORE_VALUE_KEY => Types::StringConverter.singleton.convert(value)
-          }
-        elsif pcore_type.implementation_class.respond_to?(:_pcore_init_from_hash)
-          process(value) do
-            {
-              PCORE_TYPE_KEY => pcore_tv,
-            }.merge(to_data(value._pcore_init_hash))
-          end
-        else
-          process(value) do
-            (names, _, required_count) = pcore_type.parameter_info(value.class)
-            args = names.map { |name| value.send(name) }
-
-            # Pop optional arguments that are default
-            while args.size > required_count
-              break unless pcore_type[names[args.size-1]].default_value?(args.last)
-              args.pop
-            end
-            result = {
-              PCORE_TYPE_KEY => pcore_tv
-            }
-            args.each_with_index do |val, idx|
-              key = names[idx]
-              with(key) { result[key] = to_data(val) }
-            end
-            result
-          end
-        end
-      end
-    end
-
-    def pcore_type_to_data(pcore_type)
-      type_name = pcore_type.name
-      if @type_by_reference  || type_name.start_with?('Pcore::')
-        type_name
-      else
-        with(PCORE_TYPE_KEY) { to_data(pcore_type) }
-      end
-    end
-    private :pcore_type_to_data
-
-    def serialization_issue(issue, options = EMPTY_HASH)
-      semantic = @semantic
-      if semantic.nil?
-        stacktrace = Puppet::Pops::PuppetStack.stacktrace()
-        if stacktrace.size > 0
-          file, line = stacktrace[0]
-          semantic = Puppet::Pops::SemanticError.new(issue, nil, {:file => file, :line => line})
-        else
-          semantic = Puppet::Pops::SemanticError.new(issue, nil, EMPTY_HASH)
-        end
-      end
-      optionally_fail(issue,  semantic, options)
-    end
-  end
-end
-end