bolt 0.19.1 → 0.20.0

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

@@ -1,160 +0,0 @@
-module Puppet::Pops
-module Time
-class Timestamp < TimeData
-  DEFAULT_FORMATS_WO_TZ = ['%FT%T.%N', '%FT%T', '%F %T.%N', '%F %T', '%F']
-  DEFAULT_FORMATS = ['%FT%T.%N %Z', '%FT%T %Z', '%F %T.%N %Z', '%F %T %Z', '%F %Z'] + DEFAULT_FORMATS_WO_TZ
-
-  CURRENT_TIMEZONE = 'current'.freeze
-  KEY_TIMEZONE = 'timezone'.freeze
-
-  # Converts a timezone that strptime can parse using '%z' into '-HH:MM' or '+HH:MM'
-  # @param [String] tz the timezone to convert
-  # @return [String] the converted timezone
-  #
-  # @api private
-  def self.convert_timezone(tz)
-    if tz =~ /\A[+-]\d\d:\d\d\z/
-      tz
-    else
-      offset = utc_offset(tz) / 60
-      if offset < 0
-        offset = offset.abs
-        sprintf('-%2.2d:%2.2d', offset / 60, offset % 60)
-      else
-        sprintf('+%2.2d:%2.2d', offset / 60, offset % 60)
-      end
-    end
-  end
-
-  # Returns the zone offset from utc for the given `timezone`
-  # @param [String] timezone the timezone to get the offset for
-  # @return [Integer] the timezone offset, in seconds
-  #
-  # @api private
-  def self.utc_offset(timezone)
-    if CURRENT_TIMEZONE.casecmp(timezone) == 0
-      ::Time.now.utc_offset
-    else
-      hash = DateTime._strptime(timezone, '%z')
-      offset = hash.nil? ? nil : hash[:offset]
-      raise ArgumentError, _("Illegal timezone '%{timezone}'") % { timezone: timezone } if offset.nil?
-      offset
-    end
-  end
-
-  # Formats a ruby Time object using the given timezone
-  def self.format_time(format, time, timezone)
-    unless timezone.nil? || timezone.empty?
-      time = time.localtime(convert_timezone(timezone))
-    end
-    time.strftime(format)
-  end
-
-  def self.now
-    from_time(::Time.now)
-  end
-
-  def self.from_time(t)
-    new(t.tv_sec * NSECS_PER_SEC + t.tv_nsec)
-  end
-
-  def self.from_hash(args_hash)
-    parse(args_hash[KEY_STRING], args_hash[KEY_FORMAT], args_hash[KEY_TIMEZONE])
-  end
-
-  def self.parse(str, format = :default, timezone = nil)
-    has_timezone = !(timezone.nil? || timezone.empty? || timezone == :default)
-    if format.nil? || format == :default
-      format = has_timezone ? DEFAULT_FORMATS_WO_TZ : DEFAULT_FORMATS
-    end
-
-    parsed = nil
-    if format.is_a?(Array)
-      format.each do |fmt|
-        parsed = DateTime._strptime(str, fmt)
-        next if parsed.nil?
-        if parsed.include?(:leftover) || (has_timezone && parsed.include?(:zone))
-          parsed = nil
-          next
-        end
-        break
-      end
-      if parsed.nil?
-        raise ArgumentError, _(
-          "Unable to parse '%{str}' using any of the formats %{formats}") % { str: str, formats: format.join(', ') }
-      end
-    else
-      parsed = DateTime._strptime(str, format)
-      if parsed.nil? || parsed.include?(:leftover)
-        raise ArgumentError, _("Unable to parse '%{str}' using format '%{format}'") % { str: str, format: format }
-      end
-      if has_timezone && parsed.include?(:zone)
-        raise ArgumentError, _(
-          'Using a Timezone designator in format specification is mutually exclusive to providing an explicit timezone argument')
-      end
-    end
-    unless has_timezone
-      timezone = parsed[:zone]
-      has_timezone = !timezone.nil?
-    end
-    fraction = parsed[:sec_fraction]
-
-    # Convert msec rational found in _strptime hash to usec
-    fraction = fraction * 1000000 unless fraction.nil?
-
-    # Create the Time instance and adjust for timezone
-    parsed_time = ::Time.utc(parsed[:year], parsed[:mon], parsed[:mday], parsed[:hour], parsed[:min], parsed[:sec], fraction)
-    parsed_time -= utc_offset(timezone) if has_timezone
-
-    # Convert to Timestamp
-    from_time(parsed_time)
-  end
-
-  undef_method :-@, :+@, :div, :fdiv, :abs, :abs2, :magnitude # does not make sense on a Timestamp
-  if method_defined?(:negative?)
-    undef_method :negative?, :positive?
-  end
-  if method_defined?(:%)
-    undef_method :%, :modulo, :divmod
-  end
-
-  def +(o)
-    case o
-    when Timespan
-      Timestamp.new(@nsecs + o.nsecs)
-    when Integer, Float
-      Timestamp.new(@nsecs + (o * NSECS_PER_SEC).to_i)
-    else
-      raise ArgumentError, _("%{klass} cannot be added to a Timestamp") % { klass: a_an_uc(o) }
-    end
-  end
-
-  def -(o)
-    case o
-    when Timestamp
-      # Diff between two timestamps is a timespan
-      Timespan.new(@nsecs - o.nsecs)
-    when Timespan
-      Timestamp.new(@nsecs - o.nsecs)
-    when Integer, Float
-      # Subtract seconds
-      Timestamp.new(@nsecs - (o * NSECS_PER_SEC).to_i)
-    else
-      raise ArgumentError, _("%{klass} cannot be subtracted from a Timestamp") % { klass: a_an_uc(o) }
-    end
-  end
-
-  def format(format, timezone = nil)
-    self.class.format_time(format, to_time, timezone)
-  end
-
-  def to_s
-    format(DEFAULT_FORMATS[0])
-  end
-
-  def to_time
-    ::Time.at(to_r).utc
-  end
-end
-end
-end

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

@@ -1,36 +0,0 @@
-module Puppet::Pops
-module Types
-
-KEY_ANNOTATIONS = 'annotations'.freeze
-
-# Behaviour common to all Pcore annotatable classes
-#
-# @api public
-module Annotatable
-  TYPE_ANNOTATIONS = PHashType.new(PTypeType.new(PTypeReferenceType.new('Annotation')), PHashType::DEFAULT)
-
-  # @return [{PTypeType => PStructType}] the map of annotations
-  # @api public
-  def annotations
-    @annotations.nil? ? EMPTY_HASH : @annotations
-  end
-
-  # @api private
-  def init_annotatable(init_hash)
-    @annotations = init_hash[KEY_ANNOTATIONS].freeze
-  end
-
-  # @api private
-  def annotatable_accept(visitor, guard)
-    @annotations.each_key { |key| key.accept(visitor, guard) } unless @annotations.nil?
-  end
-
-  # @api private
-  def _pcore_init_hash
-    result = {}
-    result[KEY_ANNOTATIONS] = @annotations unless @annotations.nil?
-    result
-  end
-end
-end
-end

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

@@ -1,71 +0,0 @@
-module Puppet::Pops
-module Types
-  # Pcore variant of the Adaptable::Adapter. Uses a Pcore Object type instead of a Class
-  class Annotation < Adaptable::Adapter
-    include Types::PuppetObject
-
-    CLEAR = 'clear'.freeze
-
-    # Register the Annotation type. This is the type that all custom Annotations will inherit from.
-    def self.register_ptype(loader, ir)
-      @type = Pcore::create_object_type(loader, ir, self, 'Annotation', nil, EMPTY_HASH)
-    end
-
-    def self._pcore_type
-      @type
-    end
-
-    # Finds an existing annotation for the given object and returns it.
-    # If no annotation was found, and a block is given, a new annotation is created from the
-    # initializer hash that must be returned from the block.
-    # If no annotation was found and no block is given, this method returns `nil`
-    #
-    # @param o [Object] object to annotate
-    # @param block [Proc] optional, evaluated when a new annotation must be created. Should return the init hash
-    # @return [Annotation<self>] an annotation of the same class as the receiver of the call
-    #
-    def self.annotate(o)
-      adapter = get(o)
-      if adapter.nil?
-        if o.is_a?(Annotatable)
-          init_hash = o.annotations[_pcore_type]
-          init_hash = yield if init_hash.nil? && block_given?
-        else
-          init_hash = yield if block_given?
-        end
-        adapter = associate_adapter(_pcore_type.from_hash(init_hash), o) unless init_hash.nil?
-      end
-      adapter
-    end
-
-    # Forces the creation or removal of an annotation of this type.
-    # If `init_hash` is a hash, a new annotation is created and returned
-    # If `init_hash` is `nil`, then the annotation is cleared and the previous annotation is returned.
-    #
-    # @param o [Object] object to annotate
-    # @param init_hash [Hash{String,Object},nil] the initializer for the annotation or `nil` to clear the annotation
-    # @return [Annotation<self>] an annotation of the same class as the receiver of the call
-    #
-    def self.annotate_new(o, init_hash)
-      if o.is_a?(Annotatable) && o.annotations.include?(_pcore_type)
-        # Prevent clear or redefine of annotations declared on type
-        action = init_hash == CLEAR ? 'clear' : 'redefine'
-        raise ArgumentError, "attempt to #{action} #{type_name} annotation declared on #{o.label}"
-      end
-
-      if init_hash == CLEAR
-        clear(o)
-      else
-        associate_adapter(_pcore_type.from_hash(init_hash), o)
-      end
-    end
-
-    # Uses name of type instead of name of the class (the class is likely dynamically generated and as such,
-    # has no name)
-    # @return [String] the name of the type
-    def self.type_name
-      _pcore_type.name
-    end
-  end
-end
-end

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

@@ -1,132 +0,0 @@
-module Puppet::Pops
-module Types
-# The ClassLoader provides a Class instance given a class name or a meta-type.
-# If the class is not already loaded, it is loaded using the Puppet Autoloader.
-# This means it can load a class from a gem, or from puppet modules.
-#
-class ClassLoader
-  @autoloader = Puppet::Util::Autoload.new("ClassLoader", "")
-
-  # Returns a Class given a fully qualified class name.
-  # Lookup of class is never relative to the calling namespace.
-  # @param name [String, Array<String>, Array<Symbol>, PAnyType] A fully qualified
-  #   class name String (e.g. '::Foo::Bar', 'Foo::Bar'), a PAnyType, or a fully qualified name in Array form where each part
-  #   is either a String or a Symbol, e.g. `%w{Puppetx Puppetlabs SomeExtension}`.
-  # @return [Class, nil] the looked up class or nil if no such class is loaded
-  # @raise ArgumentError If the given argument has the wrong type
-  # @api public
-  #
-  def self.provide(name)
-    case name
-    when String
-      provide_from_string(name)
-
-    when Array
-      provide_from_name_path(name.join('::'), name)
-
-    when PAnyType, PTypeType
-      provide_from_type(name)
-
-    else
-      raise ArgumentError, "Cannot provide a class from a '#{name.class.name}'"
-    end
-  end
-
-  def self.provide_from_type(type)
-    case type
-    when PRuntimeType
-      raise ArgumentError.new("Only Runtime type 'ruby' is supported, got #{type.runtime}") unless type.runtime == :ruby
-      provide_from_string(type.runtime_type_name)
-
-    when PBooleanType
-      # There is no other thing to load except this Enum meta type
-      RGen::MetamodelBuilder::MMBase::Boolean
-
-    when PTypeType
-      # TODO: PTypeType should have a type argument (a PAnyType) so the Class' class could be returned
-      #       (but this only matters in special circumstances when meta programming has been used).
-      Class
-
-    when POptionalType
-      # cannot make a distinction between optional and its type
-      provide_from_type(type.optional_type)
-
-    # Although not expected to be the first choice for getting a concrete class for these
-    # types, these are of value if the calling logic just has a reference to type.
-    #
-    when PArrayType    ; Array
-    when PTupleType    ; Array
-    when PHashType     ; Hash
-    when PStructType   ; Hash
-    when PRegexpType   ; Regexp
-    when PIntegerType  ; Integer
-    when PStringType   ; String
-    when PPatternType  ; String
-    when PEnumType     ; String
-    when PFloatType    ; Float
-    when PUndefType    ; NilClass
-    when PCallableType ; Proc
-    else
-      nil
-    end
-  end
-  private_class_method :provide_from_type
-
-  def self.provide_from_string(name)
-    name_path = name.split(TypeFormatter::NAME_SEGMENT_SEPARATOR)
-    # always from the root, so remove an empty first segment
-    name_path.shift if name_path[0].empty?
-    provide_from_name_path(name, name_path)
-  end
-
-  def self.provide_from_name_path(name, name_path)
-    # If class is already loaded, try this first
-    result = find_class(name_path)
-
-    unless result.is_a?(Module)
-      # Attempt to load it using the auto loader
-      loaded_path = nil
-      if paths_for_name(name_path).find {|path| loaded_path = path; @autoloader.load(path, Puppet.lookup(:current_environment)) }
-        result = find_class(name_path)
-        unless result.is_a?(Module)
-          raise RuntimeError, "Loading of #{name} using relative path: '#{loaded_path}' did not create expected class"
-        end
-      end
-    end
-    return nil unless result.is_a?(Module)
-    result
-  end
-  private_class_method :provide_from_string
-
-  def self.find_class(name_path)
-    name_path.reduce(Object) do |ns, name|
-      begin
-        ns.const_get(name, false) # don't search ancestors
-      rescue NameError
-        return nil
-      end
-    end
-  end
-  private_class_method :find_class
-
-  def self.paths_for_name(fq_named_parts)
-    # search two entries, one where all parts are decamelized, and one with names just downcased
-    # TODO:this is not perfect - it will not produce the correct mix if a mix of styles are used
-    # The alternative is to test many additional paths.
-    #
-    [fq_named_parts.map {|part| de_camel(part)}.join('/'), fq_named_parts.join('/').downcase ]
-  end
-  private_class_method :paths_for_name
-
-  def self.de_camel(fq_name)
-    fq_name.to_s.gsub(/::/, '/').
-    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-    gsub(/([a-z\d])([A-Z])/,'\1_\2').
-    tr("-", "_").
-    downcase
-  end
-  private_class_method :de_camel
-
-end
-end
-end

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

@@ -1,16 +0,0 @@
-# The Enumeration class provides default Enumerable::Enumerator creation for Puppet Programming Language
-# runtime objects that supports the concept of enumeration.
-#
-module Puppet::Pops::Types
-  class Enumeration
-    def self.enumerator(o)
-      Puppet.deprecation_warning(_('Enumeration.enumerator is deprecated. Use Iterable.on instead'))
-      Iterable.on(o)
-    end
-
-    def enumerator(o)
-      Puppet.deprecation_warning(_('Enumeration.enumerator is deprecated. Use Iterable.on instead'))
-      Iterable.on(o)
-    end
-  end
-end

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

@@ -1,134 +0,0 @@
-module Puppet::Pops
-module Types
-  # The {ImplementationRegistry} maps names types in the Puppet Type System to names of corresponding implementation
-  # modules/classes. Each mapping is unique and bidirectional so that for any given type name there is only one
-  # implementation and vice versa.
-  #
-  # @api private
-  class ImplementationRegistry
-    TYPE_REGEXP_SUBST = TypeFactory.tuple([PRegexpType::DEFAULT, PStringType::NON_EMPTY])
-
-    # Create a new instance. This method is normally only called once
-    #
-    # @param parent [ImplementationRegistry, nil] the parent of this registry
-    def initialize(parent = nil)
-      @parent = parent
-      @type_names_per_implementation = {}
-      @implementations_per_type_name = {}
-      @type_name_substitutions = []
-      @impl_name_substitutions = []
-    end
-
-    # Register a bidirectional type mapping.
-    #
-    # @overload register_type_mapping(runtime_type, puppet_type)
-    #   @param runtime_type [PRuntimeType] type that represents the runtime module or class to map to a puppet type
-    #   @param puppet_type [PAnyType] type that will be mapped to the runtime module or class
-    # @overload register_type_mapping(runtime_type, pattern_replacement)
-    #   @param runtime_type [PRuntimeType] type containing the pattern and replacement to map the runtime type to a puppet type
-    #   @param puppet_type [Array(Regexp,String)] the pattern and replacement to map a puppet type to a runtime type
-    def register_type_mapping(runtime_type, puppet_type_or_pattern, _ = nil)
-      TypeAsserter.assert_assignable('First argument of type mapping', PRuntimeType::RUBY, runtime_type)
-      expr = runtime_type.name_or_pattern
-      if expr.is_a?(Array)
-        TypeAsserter.assert_instance_of('Second argument of type mapping', TYPE_REGEXP_SUBST, puppet_type_or_pattern)
-        register_implementation_regexp(puppet_type_or_pattern, expr)
-      else
-        TypeAsserter.assert_instance_of('Second argument of type mapping', PTypeType::DEFAULT, puppet_type_or_pattern)
-        register_implementation(puppet_type_or_pattern, expr)
-      end
-    end
-
-    # Register a bidirectional namespace mapping
-    #
-    # @param type_namespace [String] the namespace for the puppet types
-    # @param impl_namespace [String] the namespace for the implementations
-    def register_implementation_namespace(type_namespace, impl_namespace, _ = nil)
-      ns = TypeFormatter::NAME_SEGMENT_SEPARATOR
-      register_implementation_regexp(
-        [/\A#{type_namespace}#{ns}(\w+)\z/, "#{impl_namespace}#{ns}\\1"],
-        [/\A#{impl_namespace}#{ns}(\w+)\z/, "#{type_namespace}#{ns}\\1"])
-    end
-
-    # Register a bidirectional regexp mapping
-    #
-    # @param type_name_subst [Array(Regexp,String)] regexp and replacement mapping type names to runtime names
-    # @param impl_name_subst [Array(Regexp,String)] regexp and replacement mapping runtime names to type names
-    def register_implementation_regexp(type_name_subst, impl_name_subst, _ = nil)
-      @type_name_substitutions << type_name_subst
-      @impl_name_substitutions << impl_name_subst
-      nil
-    end
-
-    # Register a bidirectional mapping between a type and an implementation
-    #
-    # @param type [PAnyType,String] the type or type name
-    # @param impl_module[Module,String] the module or module name
-    def register_implementation(type, impl_module, _ = nil)
-      type = type.name if type.is_a?(PAnyType)
-      impl_module = impl_module.name if impl_module.is_a?(Module)
-      @type_names_per_implementation[impl_module] = type
-      @implementations_per_type_name[type] = impl_module
-      nil
-    end
-
-    # Find the name for the module that corresponds to the given type or type name
-    #
-    # @param type [PAnyType,String] the name of the type
-    # @return [String,nil] the name of the implementation module, or `nil` if no mapping was found
-    def module_name_for_type(type)
-      type = type.name if type.is_a?(PAnyType)
-      name = @parent.module_name_for_type(type) unless @parent.nil?
-      name.nil? ? find_mapping(type, @implementations_per_type_name, @type_name_substitutions) : name
-    end
-
-    # Find the module that corresponds to the given type or type name
-    #
-    # @param type [PAnyType,String] the name of the type
-    # @return [Module,nil] the name of the implementation module, or `nil` if no mapping was found
-    def module_for_type(type)
-      name = module_name_for_type(type)
-      # TODO Shouldn't ClassLoader be module specific?
-      name.nil? ? nil : ClassLoader.provide(name)
-    end
-
-    # Find the type name and loader that corresponds to the given runtime module or module name
-    #
-    # @param impl_module [Module,String] the implementation class or class name
-    # @return [String,nil] the name of the type, or `nil` if no mapping was found
-    def type_name_for_module(impl_module)
-      impl_module = impl_module.name if impl_module.is_a?(Module)
-      name = @parent.type_name_for_module(impl_module) unless @parent.nil?
-      name.nil? ? find_mapping(impl_module, @type_names_per_implementation, @impl_name_substitutions) : name
-    end
-
-    # Find the name for, and then load, the type  that corresponds to the given runtime module or module name
-    # The method will return `nil` if no mapping is found, a TypeReference if a mapping was found but the
-    # loader didn't find the type, or the loaded type.
-    #
-    # @param impl_module [Module,String] the implementation class or class name
-    # @return [PAnyType,nil] the type, or `nil` if no mapping was found
-    def type_for_module(impl_module)
-      name = type_name_for_module(impl_module)
-      if name.nil?
-        nil
-      else
-        TypeParser.singleton.parse(name)
-      end
-    end
-
-    private
-
-    def find_mapping(name, names, substitutions)
-      found = names[name]
-      if found.nil?
-        substitutions.each do |subst|
-          substituted = name.sub(*subst)
-          return substituted unless substituted == name
-        end
-      end
-      found
-    end
-  end
-end
-end