Method: Puppet::Property#insync?

Defined in:
lib/puppet/property.rb

#insync?(is) ⇒ Boolean

TODO:

The implementation should really do return is.zip(@should).all? {|a, b| property_matches?(a, b) } instead of using equality check and then check against an array with converted strings.

Note:

The array matching logic in this method contains backwards compatible logic that performs the comparison in ‘:all` mode by checking equality and equality of is against should converted to array of String, and that the lengths are equal, and in `:first` mode by checking if one of the should values is included in the is values. This means that the is value needs to be carefully arranged to match the should.

Checks if the current _(is)_ value is in sync with the wanted _(should)_ value. The check if the two values are in sync is controlled by the result of #match_all? which specifies a match of ‘:first` or `:all`). The matching of the is value against the entire should value or each of the should values (as controlled by #match_all? is performed by #property_matches?.

A derived property typically only needs to override the #property_matches? method, but may also override this method if there is a need to have more control over the array matching logic.

Parameters:

  • is (Object) —

    The current _(is)_ value to check if it is in sync with the wanted _(should)_ value(s)

Returns:

  • (Boolean) —

    whether the values are in sync or not.

Raises:



308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
 
# File 'lib/puppet/property.rb', line 308

def insync?(is)
  devfail "#{self.class.name}'s should is not array" unless @should.is_a?(Array)

  # an empty array is analogous to no should values
  return true if @should.empty?

  # Look for a matching value, either for all the @should values, or any of
  # them, depending on the configuration of this property.
  if match_all? then
    # Emulate Array#== using our own comparison function.
    # A non-array was not equal to an array, which @should always is.
    return false unless is.is_a? Array

    # If they were different lengths, they are not equal.
    return false unless is.length == @should.length

    # Finally, are all the elements equal?  In order to preserve the
    # behaviour of previous 2.7.x releases, we need to impose some fun rules
    # on "equality" here.
    #
    # Specifically, we need to implement *this* comparison: the two arrays
    # are identical if the is values are == the should values, or if the is
    # values are == the should values, stringified.
    #
    # This does mean that property equality is not commutative, and will not
    # work unless the `is` value is carefully arranged to match the should.
    (is == @should or is == @should.map(&:to_s))

    # When we stop being idiots about this, and actually have meaningful
    # semantics, this version is the thing we actually want to do.
    #
    # return is.zip(@should).all? {|a, b| property_matches?(a, b) }
  else
    @should.any? { |want| property_matches?(is, want) }
  end
end