bolt 0.0.1 → 0.5.0

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

@@ -0,0 +1,160 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,129 @@
+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
+
+  private
+
+  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
+
+  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
+
+  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
+
+  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
+
+  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
+
+end
+end
+end

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

@@ -0,0 +1,16 @@
+# 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/execution_result.rb

@@ -0,0 +1,126 @@
+module Puppet::Pops
+module Types
+  class ExecutionResult
+    include PuppetObject
+    include Iterable
+    include IteratorProducer
+
+    TYPE_RESULT_HASH = TypeFactory.hash_kv(PStringType::NON_EMPTY, TypeFactory.struct({
+      TypeFactory.optional('value') => TypeFactory.data,
+      TypeFactory.optional('error') => TypeFactory.struct({
+        'msg' => PStringType::NON_EMPTY,
+        TypeFactory.optional('kind') => PStringType::NON_EMPTY,
+        TypeFactory.optional('issue_code') => PStringType::NON_EMPTY,
+        TypeFactory.optional('details') => TypeFactory.hash_of_data,
+      })
+    }))
+
+    TYPE_RESULT_ERRORS = TypeFactory.hash_kv(PStringType::NON_EMPTY, TypeFactory.variant(TypeFactory.error, TypeFactory.data))
+
+    def self.register_ptype(loader, ir)
+      @type = Pcore::create_object_type(loader, ir, self, 'ExecutionResult', nil,
+        { 'result_hash' => TYPE_RESULT_HASH },
+        {
+          'count' => TypeFactory.callable([], TypeFactory.integer),
+          'empty' => TypeFactory.callable([], TypeFactory.boolean),
+          'error_nodes' => TypeFactory.callable([], TypeFactory.type_reference('ExecutionResult')),
+          'names' => TypeFactory.callable([], TypeFactory.array_of(PStringType::NON_EMPTY)),
+          'ok' => TypeFactory.callable([], TypeFactory.boolean),
+          'ok_nodes' => TypeFactory.callable([], TypeFactory.type_reference('ExecutionResult')),
+          'value' => TypeFactory.callable([PStringType::NON_EMPTY], TypeFactory.variant(TypeFactory.error, TypeFactory.data)),
+          'values' => TypeFactory.callable([], TypeFactory.array_of(TypeFactory.variant(TypeFactory.error, TypeFactory.data))),
+          '[]' => TypeFactory.callable([PStringType::NON_EMPTY], TypeFactory.variant(TypeFactory.error, TypeFactory.data)),
+        })
+    end
+
+    def self._pcore_type
+      @type
+    end
+
+    # Creates a pure Data hash from a result hash returned from the Bolt::Executor
+    # @return [Hash{String => Data}] The data hash
+    def self.from_bolt(result_hash)
+      data_result = {}
+      result_hash.each_pair { |k, v| data_result[k.uri] = v.to_h }
+      self.new(data_result)
+    end
+
+    attr_reader :result_hash
+
+    def initialize(result_hash)
+      @result_hash = convert_errors(result_hash)
+    end
+
+    def count
+      @result_hash.size
+    end
+
+    def empty
+      @result_hash.empty?
+    end
+    alias_method :empty?, :empty
+
+    def error_nodes
+      result = {}
+      @result_hash.each_pair { |k, v| result[k] = v if v.is_a?(PErrorType::Error) }
+      self.class.new(result)
+    end
+
+    def iterator
+      Iterable.on(@result_hash)
+    end
+
+    def names
+      @result_hash.keys
+    end
+
+    def ok
+      !@result_hash.values.any? { |v| v.is_a?(PErrorType::Error) }
+    end
+    alias_method :ok?, :ok
+
+    def ok_nodes
+      result = {}
+      @result_hash.each_pair { |k, v| result[k] = v unless v.is_a?(PErrorType::Error) }
+      self.class.new(result)
+    end
+
+    def [](node_uri)
+      @result_hash[node_uri]
+    end
+
+    def value(node_uri)
+      self[node_uri]
+    end
+
+    def values
+      @result_hash.values
+    end
+
+    def _pcore_init_hash
+      @result_hash
+    end
+
+    private
+
+    def convert_errors(result_hash)
+      return result_hash unless TYPE_RESULT_HASH.instance?(result_hash)
+      converted = {}
+      result_hash.each_pair { |k, v| converted[k] = convert_error(v) }
+      converted
+    end
+
+    def convert_error(value_or_error)
+      error = value_or_error['error']
+      value = value_or_error['value']
+      if error.nil?
+        value
+      else
+        PErrorType::Error.new(error['msg'], error['kind'], error['issue_code'] || PErrorType::DEFAULT_ISSUE_CODE, value, error['details'])
+      end
+    end
+
+    EMPTY_RESULT = ExecutionResult.new(EMPTY_HASH)
+  end
+end
+end