ansible-ruby 1.0.22 → 1.0.23

data/lib/ansible/ruby/modules/generated/storage/purestorage/purefa_volume.rb

@@ -18,15 +18,15 @@ module Ansible
 
         # @return [:absent, :present, nil] Define whether the volume should exist or not.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
 
         # @return [:yes, :no, nil] Define whether to eradicate the volume on delete or leave in trash.
         attribute :eradicate
-        validates :eradicate, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :eradicate, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Define whether to overwrite a target volume if it already exisits.
         attribute :overwrite
-        validates :overwrite, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :overwrite, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] Volume size in M, G, T or P units.
         attribute :size

data/lib/ansible/ruby/modules/generated/storage/purestorage/purefb_fs.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Create, delete or modifies a filesystem.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
 
         # @return [Symbol, nil] Define whether to eradicate the filesystem on delete or leave in trash.
         attribute :eradicate
@@ -26,7 +26,7 @@ module Ansible
 
         # @return [Boolean, nil] Define whether to NFS protocol is enabled for the filesystem.
         attribute :nfs
-        validates :nfs, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :nfs, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Array<String>, String, nil] Define the NFS rules in operation.
         attribute :nfs_rules

data/lib/ansible/ruby/modules/generated/storage/purestorage/purefb_snap.rb

@@ -18,11 +18,11 @@ module Ansible
 
         # @return [:absent, :present, nil] Define whether the filesystem snapshot should exist or not.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
 
         # @return [:yes, :no, nil] Define whether to eradicate the snapshot on delete or leave in trash.
         attribute :eradicate
-        validates :eradicate, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :eradicate, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/storage/zfs/zfs.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:absent, :present] Whether to create (C(present)), or remove (C(absent)) a file system, snapshot or volume. All parents/children will be created/destroyed as needed to reach the desired state.
         attribute :state
-        validates :state, presence: true, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}
+        validates :state, presence: true, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}
 
         # @return [String, nil] Snapshot from which to create a clone.
         attribute :origin

data/lib/ansible/ruby/modules/generated/storage/zfs/zfs_facts.rb

@@ -14,11 +14,11 @@ module Ansible
 
         # @return [:yes, :no, nil] Specifies if properties for any children should be recursively displayed.
         attribute :recurse
-        validates :recurse, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :recurse, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Specifies if property values should be displayed in machine friendly format.
         attribute :parsable
-        validates :parsable, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :parsable, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] Specifies which dataset properties should be queried in comma-separated format. For more information about dataset properties, check zfs(1M) man page.
         attribute :properties
@@ -26,7 +26,7 @@ module Ansible
 
         # @return [:all, :filesystem, :volume, :snapshot, :bookmark, nil] Specifies which datasets types to display. Multiple values have to be provided in comma-separated form.
         attribute :type
-        validates :type, inclusion: {:in=>[:all, :filesystem, :volume, :snapshot, :bookmark], :message=>"%{value} needs to be :all, :filesystem, :volume, :snapshot, :bookmark"}, allow_nil: true
+        validates :type, expression_inclusion: {:in=>[:all, :filesystem, :volume, :snapshot, :bookmark], :message=>"%{value} needs to be :all, :filesystem, :volume, :snapshot, :bookmark"}, allow_nil: true
 
         # @return [Object, nil] Specifiies recurion depth.
         attribute :depth

data/lib/ansible/ruby/modules/generated/system/aix_inittab.rb

@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:boot, :bootwait, :hold, :initdefault, false, :once, :ondemand, :powerfail, :powerwait, :respawn, :sysinit, :wait] Action what the init has to do with this entry.
         attribute :action
-        validates :action, presence: true, inclusion: {:in=>[:boot, :bootwait, :hold, :initdefault, false, :once, :ondemand, :powerfail, :powerwait, :respawn, :sysinit, :wait], :message=>"%{value} needs to be :boot, :bootwait, :hold, :initdefault, false, :once, :ondemand, :powerfail, :powerwait, :respawn, :sysinit, :wait"}
+        validates :action, presence: true, expression_inclusion: {:in=>[:boot, :bootwait, :hold, :initdefault, false, :once, :ondemand, :powerfail, :powerwait, :respawn, :sysinit, :wait], :message=>"%{value} needs to be :boot, :bootwait, :hold, :initdefault, false, :once, :ondemand, :powerfail, :powerwait, :respawn, :sysinit, :wait"}
 
         # @return [String] What command has to run.
         attribute :command
@@ -30,7 +30,7 @@ module Ansible
 
         # @return [:absent, :present, nil] Whether the entry should be present or absent in the inittab file.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/system/aix_lvol.rb

@@ -30,11 +30,11 @@ module Ansible
 
         # @return [:maximum, :minimum, nil] Sets the interphysical volume allocation policy. C(maximum) allocates logical partitions across the maximum number of physical volumes. C(minimum) allocates logical partitions across the minimum number of physical volumes.
         attribute :policy
-        validates :policy, inclusion: {:in=>[:maximum, :minimum], :message=>"%{value} needs to be :maximum, :minimum"}, allow_nil: true
+        validates :policy, expression_inclusion: {:in=>[:maximum, :minimum], :message=>"%{value} needs to be :maximum, :minimum"}, allow_nil: true
 
         # @return [:absent, :present, nil] Control if the logical volume exists. If C(present) and the volume does not already exist then the C(size) option is required.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
 
         # @return [String, nil] Free-form options to be passed to the mklv command.
         attribute :opts

data/lib/ansible/ruby/modules/generated/system/at.rb

@@ -22,15 +22,15 @@ module Ansible
 
         # @return [:minutes, :hours, :days, :weeks] The type of units in the future to execute the command or script file.
         attribute :units
-        validates :units, presence: true, inclusion: {:in=>[:minutes, :hours, :days, :weeks], :message=>"%{value} needs to be :minutes, :hours, :days, :weeks"}
+        validates :units, presence: true, expression_inclusion: {:in=>[:minutes, :hours, :days, :weeks], :message=>"%{value} needs to be :minutes, :hours, :days, :weeks"}
 
         # @return [:absent, :present, nil] The state dictates if the command or script file should be evaluated as present(added) or absent(deleted).
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
 
         # @return [:yes, :no, nil] If a matching job is present a new job will not be added.
         attribute :unique
-        validates :unique, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :unique, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/system/authorized_key.rb

@@ -22,11 +22,11 @@ module Ansible
 
         # @return [:yes, :no, nil] Whether this module should manage the directory of the authorized key file.  If set, the module will create the directory, as well as set the owner and permissions of an existing directory. Be sure to set C(manage_dir=no) if you are using an alternate directory for authorized_keys, as set with C(path), since you could lock yourself out of SSH access. See the example below.
         attribute :manage_dir
-        validates :manage_dir, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :manage_dir, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:present, :absent, nil] Whether the given key (with the given key_options) should or should not be in the file
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
 
         # @return [Array<String>, String, nil] A string of ssh key options to be prepended to the key in the authorized_keys file
         attribute :key_options
@@ -34,18 +34,18 @@ module Ansible
 
         # @return [:yes, :no, nil] Whether to remove all other non-specified keys from the authorized_keys file. Multiple keys can be specified in a single C(key) string value by separating them by newlines.,This option is not loop aware, so if you use C(with_) , it will be exclusive per iteration of the loop, if you want multiple keys in the file you need to pass them all to C(key) in a single batch as mentioned above.
         attribute :exclusive
-        validates :exclusive, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :exclusive, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] This only applies if using a https url as the source of the keys. If set to C(no), the SSL certificates will not be validated.,This should only set to C(no) used on personally controlled sites using self-signed certificates as it avoids verifying the source site.,Prior to 2.1 the code worked as if this was set to C(yes).
         attribute :validate_certs
-        validates :validate_certs, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :validate_certs, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Object, nil] Change the comment on the public key. Rewriting the comment is useful in cases such as fetching it from GitHub or GitLab.,If no comment is specified, the existing comment will be kept.
         attribute :comment
 
         # @return [:yes, :no, nil] Follow path symlink instead of replacing it
         attribute :follow
-        validates :follow, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :follow, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/system/awall.rb

@@ -14,11 +14,11 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] The policy(ies) will be C(enabled),The policy(ies) will be C(disabled)
         attribute :state
-        validates :state, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [:yes, :no, nil] Activate the new firewall rules. Can be run with other steps or on it's own.
         attribute :activate
-        validates :activate, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :activate, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/system/beadm.rb

@@ -15,23 +15,23 @@ module Ansible
 
         # @return [Boolean, nil] If specified, the new boot environment will be cloned from the given snapshot or inactive boot environment.
         attribute :snapshot
-        validates :snapshot, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :snapshot, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Boolean, nil] Associate a description with a new boot environment. This option is available only on Solarish platforms.
         attribute :description
-        validates :description, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :description, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Boolean, nil] Create the datasets for new BE with specific ZFS properties. Multiple options can be specified. This option is available only on Solarish platforms.
         attribute :options
-        validates :options, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :options, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Boolean, nil] Path where to mount the ZFS boot environment
         attribute :mountpoint
-        validates :mountpoint, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :mountpoint, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [:present, :absent, :activated, :mounted, :unmounted, nil] Create or delete ZFS boot environment.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent, :activated, :mounted, :unmounted], :message=>"%{value} needs to be :present, :absent, :activated, :mounted, :unmounted"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent, :activated, :mounted, :unmounted], :message=>"%{value} needs to be :present, :absent, :activated, :mounted, :unmounted"}, allow_nil: true
 
         # @return [Symbol, nil] Specifies if the unmount should be forced.
         attribute :force

data/lib/ansible/ruby/modules/generated/system/capabilities.rb

@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:absent, :present, nil] Whether the entry should be present or absent in the file's capabilities.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/system/cron.rb

@@ -25,7 +25,7 @@ module Ansible
 
         # @return [:absent, :present, nil] Whether to ensure the job or environment variable is present or absent.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
 
         # @return [String, nil] If specified, uses this file instead of an individual user's crontab. If this is a relative path, it is interpreted with respect to /etc/cron.d. (If it is absolute, it will typically be /etc/crontab). Many linux distros expect (and some require) the filename portion to consist solely of upper- and lower-case letters, digits, underscores, and hyphens. To use the C(cron_file) parameter you must specify the C(user) as well.
         attribute :cron_file
@@ -33,7 +33,7 @@ module Ansible
 
         # @return [:yes, :no, nil] If set, create a backup of the crontab before it is modified. The location of the backup is returned in the C(backup_file) variable by this module.
         attribute :backup
-        validates :backup, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :backup, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] Minute when the job should run ( 0-59, *, */2, etc )
         attribute :minute
@@ -57,19 +57,19 @@ module Ansible
 
         # @return [:yes, :no, nil] If the job should be run at reboot. This option is deprecated. Users should use special_time.
         attribute :reboot
-        validates :reboot, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :reboot, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:reboot, :yearly, :annually, :monthly, :weekly, :daily, :hourly, nil] Special time specification nickname.
         attribute :special_time
-        validates :special_time, inclusion: {:in=>[:reboot, :yearly, :annually, :monthly, :weekly, :daily, :hourly], :message=>"%{value} needs to be :reboot, :yearly, :annually, :monthly, :weekly, :daily, :hourly"}, allow_nil: true
+        validates :special_time, expression_inclusion: {:in=>[:reboot, :yearly, :annually, :monthly, :weekly, :daily, :hourly], :message=>"%{value} needs to be :reboot, :yearly, :annually, :monthly, :weekly, :daily, :hourly"}, allow_nil: true
 
         # @return [:yes, :no, nil] If the job should be disabled (commented out) in the crontab.,Only has effect if C(state=present).
         attribute :disabled
-        validates :disabled, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :disabled, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] If set, manages a crontab's environment variable. New variables are added on top of crontab. "name" and "value" parameters are the name and the value of environment variable.
         attribute :env
-        validates :env, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :env, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] Used with C(state=present) and C(env). If specified, the environment variable will be inserted after the declaration of specified environment variable.
         attribute :insertafter

data/lib/ansible/ruby/modules/generated/system/cronvar.rb

@@ -24,7 +24,7 @@ module Ansible
 
         # @return [:absent, :present, nil] Whether to ensure that the variable is present or absent.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
 
         # @return [String, nil] The specific user whose crontab should be modified.
         attribute :user
@@ -36,7 +36,7 @@ module Ansible
 
         # @return [:yes, :no, nil] If set, create a backup of the crontab before it is modified. The location of the backup is returned in the C(backup) variable by this module.
         attribute :backup
-        validates :backup, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :backup, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/system/crypttab.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:absent, :opts_absent, :opts_present, :present] Use I(present) to add a line to C(/etc/crypttab) or update it's definition if already present. Use I(absent) to remove a line with matching I(name). Use I(opts_present) to add options to those already present; options with different values will be updated. Use I(opts_absent) to remove options from the existing set.
         attribute :state
-        validates :state, presence: true, inclusion: {:in=>[:absent, :opts_absent, :opts_present, :present], :message=>"%{value} needs to be :absent, :opts_absent, :opts_present, :present"}
+        validates :state, presence: true, expression_inclusion: {:in=>[:absent, :opts_absent, :opts_present, :present], :message=>"%{value} needs to be :absent, :opts_absent, :opts_present, :present"}
 
         # @return [Object, nil] Path to the underlying block device or file, or the UUID of a block-device prefixed with I(UUID=).
         attribute :backing_device

data/lib/ansible/ruby/modules/generated/system/dconf.rb

@@ -19,7 +19,7 @@ module Ansible
 
         # @return [:read, :present, :absent, nil] The action to take upon the key/value.
         attribute :state
-        validates :state, inclusion: {:in=>[:read, :present, :absent], :message=>"%{value} needs to be :read, :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:read, :present, :absent], :message=>"%{value} needs to be :read, :present, :absent"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/system/debconf.rb

@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:boolean, :error, :multiselect, :note, :password, :seen, :select, :string, :text, :title, :text, nil] The type of the value supplied.,C(seen) was added in 2.2.
         attribute :vtype
-        validates :vtype, inclusion: {:in=>[:boolean, :error, :multiselect, :note, :password, :seen, :select, :string, :text, :title, :text], :message=>"%{value} needs to be :boolean, :error, :multiselect, :note, :password, :seen, :select, :string, :text, :title, :text"}, allow_nil: true
+        validates :vtype, expression_inclusion: {:in=>[:boolean, :error, :multiselect, :note, :password, :seen, :select, :string, :text, :title, :text], :message=>"%{value} needs to be :boolean, :error, :multiselect, :note, :password, :seen, :select, :string, :text, :title, :text"}, allow_nil: true
 
         # @return [Array<String>, String, nil] Value to set the configuration to.
         attribute :value

data/lib/ansible/ruby/modules/generated/system/filesystem.rb

@@ -10,7 +10,7 @@ module Ansible
       class Filesystem < Base
         # @return [:btrfs, :ext2, :ext3, :ext4, :ext4dev, :f2fs, :lvm, :ocfs2, :reiserfs, :xfs, :vfat] Filesystem type to be created.,reiserfs support was added in 2.2.,lvm support was added in 2.5.,since 2.5, I(dev) can be an image file.,vfat support was added in 2.5,ocfs2 support was added in 2.6,f2fs support was added in 2.7
         attribute :fstype
-        validates :fstype, presence: true, inclusion: {:in=>[:btrfs, :ext2, :ext3, :ext4, :ext4dev, :f2fs, :lvm, :ocfs2, :reiserfs, :xfs, :vfat], :message=>"%{value} needs to be :btrfs, :ext2, :ext3, :ext4, :ext4dev, :f2fs, :lvm, :ocfs2, :reiserfs, :xfs, :vfat"}
+        validates :fstype, presence: true, expression_inclusion: {:in=>[:btrfs, :ext2, :ext3, :ext4, :ext4dev, :f2fs, :lvm, :ocfs2, :reiserfs, :xfs, :vfat], :message=>"%{value} needs to be :btrfs, :ext2, :ext3, :ext4, :ext4dev, :f2fs, :lvm, :ocfs2, :reiserfs, :xfs, :vfat"}
 
         # @return [String] Target path to device or image file.
         attribute :dev
@@ -18,11 +18,11 @@ module Ansible
 
         # @return [:yes, :no, nil] If C(yes), allows to create new filesystem on devices that already has filesystem.
         attribute :force
-        validates :force, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :force, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] If C(yes), if the block device and filesytem size differ, grow the filesystem into the space.,Supported for C(ext2), C(ext3), C(ext4), C(ext4dev), C(f2fs), C(lvm), C(xfs) and C(vfat) filesystems.,XFS Will only grow if mounted.,vFAT will likely fail if fatresize < 1.04.
         attribute :resizefs
-        validates :resizefs, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :resizefs, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] List of options to be passed to mkfs command.
         attribute :opts

data/lib/ansible/ruby/modules/generated/system/firewalld.rb

@@ -30,7 +30,7 @@ module Ansible
 
         # @return [:work, :drop, :internal, :external, :trusted, :home, :dmz, :public, :block, nil] The firewalld zone to add/remove to/from (NOTE: default zone can be configured per system but "public" is default from upstream. Available choices can be extended based on per-system configs, listed here are "out of the box" defaults).\r\n
         attribute :zone
-        validates :zone, inclusion: {:in=>[:work, :drop, :internal, :external, :trusted, :home, :dmz, :public, :block], :message=>"%{value} needs to be :work, :drop, :internal, :external, :trusted, :home, :dmz, :public, :block"}, allow_nil: true
+        validates :zone, expression_inclusion: {:in=>[:work, :drop, :internal, :external, :trusted, :home, :dmz, :public, :block], :message=>"%{value} needs to be :work, :drop, :internal, :external, :trusted, :home, :dmz, :public, :block"}, allow_nil: true
 
         # @return [Symbol, nil] Should this configuration be in the running firewalld configuration or persist across reboots. As of Ansible version 2.3, permanent operations can operate on firewalld configs when it's not running (requires firewalld >= 3.0.9). (NOTE: If this is false, immediate is assumed true.)\r\n
         attribute :permanent
@@ -38,11 +38,11 @@ module Ansible
 
         # @return [:yes, :no, nil] Should this configuration be applied immediately, if set as permanent
         attribute :immediate
-        validates :immediate, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :immediate, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:enabled, :disabled, :present, :absent] Enable or disable a setting. For ports: Should this port accept(enabled) or reject(disabled) connections. The states "present" and "absent" can only be used in zone level operations (i.e. when no other parameters but zone and state are set).\r\n
         attribute :state
-        validates :state, presence: true, inclusion: {:in=>[:enabled, :disabled, :present, :absent], :message=>"%{value} needs to be :enabled, :disabled, :present, :absent"}
+        validates :state, presence: true, expression_inclusion: {:in=>[:enabled, :disabled, :present, :absent], :message=>"%{value} needs to be :enabled, :disabled, :present, :absent"}
 
         # @return [Integer, nil] The amount of time the rule should be in effect for when non-permanent.
         attribute :timeout
@@ -50,7 +50,7 @@ module Ansible
 
         # @return [Boolean, nil] The masquerade setting you would like to enable/disable to/from zones within firewalld
         attribute :masquerade
-        validates :masquerade, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :masquerade, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/system/gconftool2.rb

@@ -18,18 +18,18 @@ module Ansible
 
         # @return [:bool, :float, :int, :string, nil] The type of value being set. This is ignored if the state is "get".
         attribute :value_type
-        validates :value_type, inclusion: {:in=>[:bool, :float, :int, :string], :message=>"%{value} needs to be :bool, :float, :int, :string"}, allow_nil: true
+        validates :value_type, expression_inclusion: {:in=>[:bool, :float, :int, :string], :message=>"%{value} needs to be :bool, :float, :int, :string"}, allow_nil: true
 
         # @return [:absent, :get, :present] The action to take upon the key/value.
         attribute :state
-        validates :state, presence: true, inclusion: {:in=>[:absent, :get, :present], :message=>"%{value} needs to be :absent, :get, :present"}
+        validates :state, presence: true, expression_inclusion: {:in=>[:absent, :get, :present], :message=>"%{value} needs to be :absent, :get, :present"}
 
         # @return [Object, nil] Specify a configuration source to use rather than the default path. See man gconftool-2(1)
         attribute :config_source
 
         # @return [:yes, :no, nil] Access the config database directly, bypassing server.  If direct is specified then the config_source must be specified as well. See man gconftool-2(1)
         attribute :direct
-        validates :direct, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :direct, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/system/getent.rb

@@ -22,7 +22,7 @@ module Ansible
 
         # @return [:yes, :no, nil] If a supplied key is missing this will make the task fail if C(yes).
         attribute :fail_key
-        validates :fail_key, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :fail_key, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/system/group.rb

@@ -18,11 +18,11 @@ module Ansible
 
         # @return [:absent, :present, nil] Whether the group should be present or not on the remote host.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
 
         # @return [:yes, :no, nil] If I(yes), indicates that the group created is a system group.
         attribute :system
-        validates :system, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :system, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] Forces the use of "local" command alternatives on platforms that implement it. This is useful in environments that use centralized authentification when you want to manipulate the local groups. I.E. it uses `lgroupadd` instead of `useradd`.,This requires that these commands exist on the targeted host, otherwise it will be a fatal error.
         attribute :local

data/lib/ansible/ruby/modules/generated/system/interfaces_file.rb

@@ -27,11 +27,11 @@ module Ansible
 
         # @return [:yes, :no, nil] Create a backup file including the timestamp information so you can get the original file back if you somehow clobbered it incorrectly.
         attribute :backup
-        validates :backup, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :backup, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:present, :absent, nil] If set to C(absent) the option or section will be removed if present instead of created.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/system/iptables.rb

@@ -11,15 +11,15 @@ module Ansible
       class Iptables < Base
         # @return [:filter, :nat, :mangle, :raw, :security, nil] This option specifies the packet matching table which the command should operate on. If the kernel is configured with automatic module loading, an attempt will be made to load the appropriate module for that table if it is not already there.
         attribute :table
-        validates :table, inclusion: {:in=>[:filter, :nat, :mangle, :raw, :security], :message=>"%{value} needs to be :filter, :nat, :mangle, :raw, :security"}, allow_nil: true
+        validates :table, expression_inclusion: {:in=>[:filter, :nat, :mangle, :raw, :security], :message=>"%{value} needs to be :filter, :nat, :mangle, :raw, :security"}, allow_nil: true
 
         # @return [:absent, :present, nil] Whether the rule should be absent or present.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
 
         # @return [:append, :insert, nil] Whether the rule should be appended at the bottom or inserted at the top.,If the rule already exists the chain won't be modified.
         attribute :action
-        validates :action, inclusion: {:in=>[:append, :insert], :message=>"%{value} needs to be :append, :insert"}, allow_nil: true
+        validates :action, expression_inclusion: {:in=>[:append, :insert], :message=>"%{value} needs to be :append, :insert"}, allow_nil: true
 
         # @return [Integer, nil] Insert the rule as the given rule number. This works only with action = 'insert'.
         attribute :rule_num
@@ -27,7 +27,7 @@ module Ansible
 
         # @return [:ipv4, :ipv6, nil] Which version of the IP protocol this rule should apply to.
         attribute :ip_version
-        validates :ip_version, inclusion: {:in=>[:ipv4, :ipv6], :message=>"%{value} needs to be :ipv4, :ipv6"}, allow_nil: true
+        validates :ip_version, expression_inclusion: {:in=>[:ipv4, :ipv6], :message=>"%{value} needs to be :ipv4, :ipv6"}, allow_nil: true
 
         # @return [String, nil] Chain to operate on.,This option can either be the name of a user defined chain or any of the builtin chains: 'INPUT', 'FORWARD', 'OUTPUT', 'PREROUTING', 'POSTROUTING', 'SECMARK', 'CONNSECMARK'.
         attribute :chain
@@ -92,7 +92,7 @@ module Ansible
 
         # @return [:ignore, :match, :negate, nil] This allows matching packets that have the SYN bit set and the ACK and RST bits unset.,When negated, this matches all packets with the RST or the ACK bits set.
         attribute :syn
-        validates :syn, inclusion: {:in=>[:ignore, :match, :negate], :message=>"%{value} needs to be :ignore, :match, :negate"}, allow_nil: true
+        validates :syn, expression_inclusion: {:in=>[:ignore, :match, :negate], :message=>"%{value} needs to be :ignore, :match, :negate"}, allow_nil: true
 
         # @return [Integer, nil] This allows specifying a DSCP mark to be added to packets. It takes either an integer or hex value.,Mutually exclusive with C(set_dscp_mark_class).
         attribute :set_dscp_mark
@@ -108,7 +108,7 @@ module Ansible
 
         # @return [:DNAT, :ESTABLISHED, :INVALID, :NEW, :RELATED, :SNAT, :UNTRACKED, nil] C(ctstate) is a list of the connection states to match in the conntrack module. Possible states are: 'INVALID', 'NEW', 'ESTABLISHED', 'RELATED', 'UNTRACKED', 'SNAT', 'DNAT'
         attribute :ctstate
-        validates :ctstate, inclusion: {:in=>[:DNAT, :ESTABLISHED, :INVALID, :NEW, :RELATED, :SNAT, :UNTRACKED], :message=>"%{value} needs to be :DNAT, :ESTABLISHED, :INVALID, :NEW, :RELATED, :SNAT, :UNTRACKED"}, allow_nil: true
+        validates :ctstate, expression_inclusion: {:in=>[:DNAT, :ESTABLISHED, :INVALID, :NEW, :RELATED, :SNAT, :UNTRACKED], :message=>"%{value} needs to be :DNAT, :ESTABLISHED, :INVALID, :NEW, :RELATED, :SNAT, :UNTRACKED"}, allow_nil: true
 
         # @return [Object, nil] Specifies the maximum average number of matches to allow per second.,The number can specify units explicitly, using `/second', `/minute', `/hour' or `/day', or parts of them (so `5/second' is the same as `5/s').
         attribute :limit
@@ -131,7 +131,7 @@ module Ansible
 
         # @return [:ACCEPT, :DROP, :QUEUE, :RETURN, nil] Set the policy for the chain to the given target.,Only built-in chains can have policies.,This parameter requires the C(chain) parameter.,Ignores all other parameters.
         attribute :policy
-        validates :policy, inclusion: {:in=>[:ACCEPT, :DROP, :QUEUE, :RETURN], :message=>"%{value} needs to be :ACCEPT, :DROP, :QUEUE, :RETURN"}, allow_nil: true
+        validates :policy, expression_inclusion: {:in=>[:ACCEPT, :DROP, :QUEUE, :RETURN], :message=>"%{value} needs to be :ACCEPT, :DROP, :QUEUE, :RETURN"}, allow_nil: true
       end
     end
   end