puppet 4.7.1-universal-darwin → 4.8.0-universal-darwin

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

@@ -0,0 +1,148 @@
+module Puppet::Pops
+module Time
+class Timestamp < TimeData
+  DEFAULT_FORMATS_WO_TZ = ['%FT%T.L', '%FT%T', '%F']
+  DEFAULT_FORMATS = ['%FT%T.%L %Z', '%FT%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}'" 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|
+        assert_no_tz_extractor(fmt) if has_timezone
+        begin
+          parsed = DateTime.strptime(str, fmt)
+          break
+        rescue ArgumentError
+        end
+      end
+      raise ArgumentError, "Unable to parse '#{str}' using any of the formats #{format.join(', ')}" if parsed.nil?
+    else
+      assert_no_tz_extractor(format) if has_timezone
+      begin
+        parsed = DateTime.strptime(str, format)
+      rescue ArgumentError
+        raise ArgumentError, "Unable to parse '#{str}' using format '#{format}'"
+      end
+    end
+    parsed_time = parsed.to_time
+    parsed_time -= utc_offset(timezone) if has_timezone
+    from_time(parsed_time)
+  end
+
+  def self.assert_no_tz_extractor(format)
+    if format =~ /[^%]%[zZ]/
+      raise ArgumentError, 'Using a Timezone designator in format specification is mutually exclusive to providing an explicit timezone argument'
+    end
+  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, "#{a_an_uc(o)} cannot be added to a Timestamp"
+    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, "#{a_an_uc(o)} cannot be subtracted from a Timestamp"
+    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/lib/puppet/pops/types/p_binary_type.rb

@@ -0,0 +1,220 @@
+require 'base64'
+module Puppet::Pops
+module Types
+
+# A Puppet Language Type that exposes the {{SemanticPuppet::Version}} and {{SemanticPuppet::VersionRange}}.
+# The version type is parameterized with version ranges.
+#
+# @api public
+class PBinaryType < PAnyType
+
+  # Represents a binary buffer
+  # @api public
+  class Binary
+    attr_reader :binary_buffer
+
+    # Constructs an instance of Binary from a base64 urlsafe encoded string (RFC 2045).
+    # @param [String] A string with RFC 2045 compliant encoded binary
+    #
+    def self.from_base64(str)
+      new(Base64.decode64(str))
+    end
+
+    # Constructs an instance of Binary from a base64 encoded string (RFC4648 with "URL and Filename
+    # Safe Alphabet" (That is with '-' instead of '+', and '_' instead of '/').
+    #
+    def self.from_base64_urlsafe(str)
+      new(Base64.urlsafe_decode64(str))
+    end
+
+    # Constructs an instance of Binary from a base64 strict encoded string (RFC 4648)
+    # Where correct padding must be used and line breaks causes an error to be raised.
+    #
+    # @param [String] A string with RFC 4648 compliant encoded binary
+    #
+    def self.from_base64_strict(str)
+      new(Base64.strict_decode64(str))
+    end
+
+    # Creates a new Binary from a String containing binary data. If the string's encoding
+    # is not already ASCII-8BIT, a copy of the string is force encoded as ASCII-8BIT (that is Ruby's "binary" format).
+    # This means that this binary will have the exact same content, but the string will considered
+    # to hold a sequence of bytes in the range 0 to 255.
+    #
+    # The given string will be frozen as a side effect if it is in ASCII-8BIT encoding. If this is not
+    # wanted, a copy should be given to this method.
+    #
+    # @param [String] A string with binary data
+    # @api public
+    #
+    def self.from_binary_string(bin)
+      new(bin)
+    end
+
+    # Creates a new Binary from a String containing text/binary in its given encoding. If the string's encoding
+    # is not already UTF-8, the string is first transcoded to UTF-8.
+    # This means that this binary will have the UTF-8 byte representation of the original string.
+    # For this to be valid, the encoding used in the given string must be valid.
+    # The validity of the given string is therefore asserted.
+    #
+    # The given string will be frozen as a side effect if it is in ASCII-8BIT encoding. If this is not
+    # wanted, a copy should be given to this method.
+    #
+    # @param [String] A string with valid content in its given encoding
+    # @return [Puppet::Pops::Types::PBinaryType::Binary] with the UTF-8 representation of the UTF-8 transcoded string
+    # @api public
+    #
+    def self.from_string(encoded_string)
+      enc = encoded_string.encoding.name
+      unless encoded_string.valid_encoding?
+        raise ArgumentError, "The given string in encoding '#{enc}' is invalid. Cannot create a Binary UTF-8 representation"
+      end
+      # Convert to UTF-8 (if not already UTF-8), and then to binary
+      encoded_string = (enc == "UTF-8") ? encoded_string.dup : encoded_string.encode('UTF-8')
+      encoded_string.force_encoding("ASCII-8BIT")
+      new(encoded_string)
+    end
+
+    # Creates a new Binary from a String containing raw binary data of unknown encoding. If the string's encoding
+    # is not already ASCII-8BIT, a copy of the string is forced to ASCII-8BIT (that is Ruby's "binary" format).
+    # This means that this binary will have the exact same content, but the string will considered
+    # to hold a sequence of bytes in the range 0 to 255.
+    #
+    # @param [String] A string with binary data
+    # @api private
+    #
+    def initialize(bin)
+      # TODO: When Ruby 1.9.3 support is dropped change this to `bin.b` for binary encoding instead of force_encoding
+      @binary_buffer = (bin.encoding.name == "ASCII-8BIT" ? bin : bin.dup.force_encoding("ASCII-8BIT")).freeze
+    end
+
+    # Presents the binary content as a string base64 encoded string (without line breaks).
+    #
+    def to_s
+      Base64.strict_encode64(@binary_buffer)
+    end
+
+    # Returns the binary content as a "relaxed" base64 (standard) encoding where
+    # the string is broken up with new lines.
+    def relaxed_to_s
+      Base64.encode64(@binary_buffer)
+    end
+
+    # Returns the binary content as a url safe base64 string (where + and / are replaced by - and _)
+    #
+    def urlsafe_to_s
+      Base64.urlsafe_encode64(@binary_buffer)
+    end
+
+    def hash
+      @binary_buffer.hash
+    end
+
+    def eql?(o)
+      self.class == o.class && @binary_buffer == o.binary_buffer
+    end
+
+    def ==(o)
+      self.eql?(o)
+    end
+
+    def length()
+      @binary_buffer.length
+    end
+  end
+
+  def self.register_ptype(loader, ir)
+    create_ptype(loader, ir, 'AnyType')
+  end
+
+  # Only instances of Binary are instances of the PBinaryType
+  #
+  def instance?(o, guard = nil)
+    o.is_a?(Binary)
+  end
+
+  def eql?(o)
+    self.class == o.class
+  end
+
+  # @api private
+  def self.new_function(_, loader)
+    @new_function ||= Puppet::Functions.create_loaded_function(:new_Binary, loader) do
+      local_types do
+        type 'ByteInteger = Integer[0,255]'
+        type 'Base64Format = Enum["%b", "%u", "%B", "%s", "%r"]'
+        type 'StringHash = Struct[{value => String, "format" => Optional[Base64Format]}]'
+        type 'ArrayHash = Struct[{value => Array[ByteInteger]}]'
+        type 'BinaryArgsHash = Variant[StringHash, ArrayHash]'
+      end
+
+      # Creates a binary from a base64 encoded string in one of the formats %b, %u, %B, %s, or %r
+      dispatch :from_string do
+        param 'String', :str
+        optional_param 'Base64Format', :format
+      end
+
+      dispatch :from_array do
+        param 'Array[ByteInteger]', :byte_array
+      end
+
+      # Same as from_string, or from_array, but value and (for string) optional format are given in the form
+      # of a hash.
+      #
+      dispatch :from_hash do
+        param 'BinaryArgsHash', :hash_args
+      end
+
+      def from_string(str, format = nil)
+        format ||= '%B'
+        case format
+        when "%b"
+          # padding must be added for older rubies to avoid truncation
+          padding = '=' * (str.length % 3)
+          Binary.new(Base64.decode64(str + padding))
+
+        when "%u"
+          Binary.new(Base64.urlsafe_decode64(str))
+
+        when "%B"
+          Binary.new(Base64.strict_decode64(str))
+
+        when "%s"
+          Binary.from_string(str)
+
+        when "%r"
+          Binary.from_binary_string(str)
+
+        else
+          raise ArgumentError, "Unsupported Base64 format '#{format}'"
+        end
+      end
+
+      def from_array(array)
+        # The array is already known to have bytes in the range 0-255, or it is in error
+        # Without this pack C would produce weird results
+        Binary.from_binary_string(array.pack("C*"))
+      end
+
+      def from_hash(hash)
+        case hash['value']
+        when Array
+          from_array(hash['value'])
+        when String
+          from_string(hash['value'], hash['format'])
+        end
+      end
+    end
+  end
+
+  DEFAULT = PBinaryType.new
+
+  protected
+
+  def _assignable?(o, guard)
+    o.class == self.class
+  end
+
+end
+end
+end

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

@@ -201,17 +201,23 @@ class PObjectType < PMetaType
       @dispatch ||= create_dispatch(receiver)
 
       args_type = TypeCalculator.infer_set(block_given? ? args + [block] : args)
-      unless @dispatch.type.callable?(args_type)
-        raise ArgumentError, TypeMismatchDescriber.describe_signatures(label, [@dispatch], args_type)
-      end
-      @dispatch.invoke(receiver, scope, args, &block)
+      found = @dispatch.find { |d| d.type.callable?(args_type) }
+      raise ArgumentError, TypeMismatchDescriber.describe_signatures(label, @dispatch, args_type) if found.nil?
+      found.invoke(receiver, scope, args, &block)
     end
 
     # @api private
     def create_dispatch(instance)
       # TODO: Assumes Ruby implementation for now
-      Functions::Dispatch.new(callable_type, name, [],
-        callable_type.block_type.nil? ? nil : 'block', nil, nil, false)
+      if(callable_type.is_a?(PVariantType))
+        callable_type.types.map do |ct|
+          Functions::Dispatch.new(ct, name, [],
+            ct.block_type.nil? ? nil : 'block', nil, nil, false)
+        end
+      else
+        [Functions::Dispatch.new(callable_type, name, [],
+          callable_type.block_type.nil? ? nil : 'block', nil, nil, false)]
+      end
     end
 
     # @api private

data/lib/puppet/pops/types/p_sensitive_type.rb

@@ -6,7 +6,7 @@ module Types
 #
 #
 # @api public
-class PSensitiveType < Puppet::Pops::Types::PTypeWithContainedType
+class PSensitiveType < PTypeWithContainedType
 
   class Sensitive
     def initialize(value)
@@ -26,6 +26,10 @@ class PSensitiveType < Puppet::Pops::Types::PTypeWithContainedType
     end
   end
 
+  def self.register_ptype(loader, ir)
+    create_ptype(loader, ir, 'AnyType')
+  end
+
   def initialize(type = nil)
     @type = type.nil? ? PAnyType.new : type.generalize
   end

data/lib/puppet/pops/types/p_timespan_type.rb

@@ -0,0 +1,141 @@
+module Puppet::Pops
+module Types
+  class PAbstractTimeDataType < PAbstractRangeType
+    # @param [AbstractTime] min lower bound for this type. Nil or :default means unbounded
+    # @param [AbstractTime] max upper bound for this type. Nil or :default means unbounded
+    def initialize(min = nil, max = nil)
+      super(convert_arg(min, true), convert_arg(max, false))
+    end
+
+    def convert_arg(arg, min)
+      case arg
+      when impl_class
+        arg
+      when Hash
+        impl_class.from_hash(arg)
+      when nil, :default
+        nil
+      when String
+        impl_class.parse(arg)
+      when Integer
+        arg == impl_class.new(arg * Time::NSECS_PER_SEC)
+      when Float
+        arg == (min ? -Float::INFINITY : Float::INFINITY) ? arg : impl_class.new(arg * Time::NSECS_PER_SEC)
+      else
+        raise ArgumentError, "Unable to create a #{impl_class.name} from a #{arg.class.name}" unless arg.nil? || arg == :default
+        nil
+      end
+    end
+
+    # Concatenates this range with another range provided that the ranges intersect or
+    # are adjacent. When that's not the case, this method will return `nil`
+    #
+    # @param o [PAbstractTimeDataType] the range to concatenate with this range
+    # @return [PAbstractTimeDataType,nil] the concatenated range or `nil` when the ranges were apart
+    # @api public
+    def merge(o)
+      if intersect?(o) || adjacent?(o)
+        new_min = numeric_from <= o.numeric_from ? numeric_from : o.numeric_from
+        new_max = numeric_to >= o.numeric_to ? numeric_to : o.numeric_to
+        self.class.new(new_min, new_max)
+      else
+        nil
+      end
+    end
+
+    def _assignable?(o, guard)
+      self.class == o.class && numeric_from <= o.numeric_from && numeric_to >= o.numeric_to
+    end
+  end
+
+  class PTimespanType < PAbstractTimeDataType
+    def self.register_ptype(loader, ir)
+      create_ptype(loader, ir, 'ScalarType',
+        'from' => { KEY_TYPE => PTimespanType::DEFAULT, KEY_VALUE => :default },
+        'to' => { KEY_TYPE => PTimespanType::DEFAULT, KEY_VALUE => :default }
+      )
+    end
+
+    def self.new_function(_, loader)
+      @new_function ||= Puppet::Functions.create_loaded_function(:new_timespan, loader) do
+        local_types do
+          type 'Formats = Variant[String[2],Array[String[2]], 1]'
+        end
+
+        dispatch :from_seconds do
+          param           'Variant[Integer,Float]', :seconds
+        end
+
+        dispatch :from_string do
+          param           'String[1]', :string
+          optional_param  'Formats', :format
+        end
+
+        dispatch :from_fields do
+          param          'Integer', :days
+          param          'Integer', :hours
+          param          'Integer', :minutes
+          param          'Integer', :seconds
+          optional_param 'Integer', :milliseconds
+          optional_param 'Integer', :microseconds
+          optional_param 'Integer', :nanoseconds
+        end
+
+        dispatch :from_string_hash do
+          param <<-TYPE, :hash_arg
+            Struct[{
+              string => String[1],
+              Optional[format] => Formats
+            }]
+          TYPE
+        end
+
+        dispatch :from_fields_hash do
+          param <<-TYPE, :hash_arg
+            Struct[{
+              Optional[negative] => Boolean,
+              Optional[days] => Integer,
+              Optional[hours] => Integer,
+              Optional[minutes] => Integer,
+              Optional[seconds] => Integer,
+              Optional[milliseconds] => Integer,
+              Optional[microseconds] => Integer,
+              Optional[nanoseconds] => Integer
+            }]
+          TYPE
+        end
+
+        def from_seconds(seconds)
+          Time::Timespan.new((seconds * Time::NSECS_PER_SEC).to_i)
+        end
+
+        def from_string(string, format = Time::Timespan::Format::DEFAULTS)
+          Time::Timespan.parse(string, format)
+        end
+
+        def from_fields(days, hours, minutes, seconds, milliseconds = 0, microseconds = 0, nanoseconds = 0)
+          Time::Timespan.from_fields(days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds)
+        end
+
+        def from_string_hash(args_hash)
+          Time::Timespan.from_string_hash(args_hash)
+        end
+
+        def from_fields_hash(args_hash)
+          Time::Timespan.from_fields_hash(args_hash)
+        end
+      end
+    end
+
+    def generalize
+      DEFAULT
+    end
+
+    def impl_class
+      Time::Timespan
+    end
+
+    DEFAULT = PTimespanType.new(nil, nil)
+  end
+end
+end