ansible-ruby 1.0.22 → 1.0.23

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

@@ -45,7 +45,7 @@ module Ansible
 
         # @return [Boolean, nil] Create keystore if it doesn't exist
         attribute :keystore_create
-        validates :keystore_create, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :keystore_create, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [String, nil] Path to keytool binary if not used we search in PATH for it.
         attribute :executable
@@ -53,7 +53,7 @@ module Ansible
 
         # @return [:absent, :present, nil] Defines action which can be either certificate import or removal.
         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/java_keystore.rb

@@ -39,7 +39,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Key store will be created even if it already exists.
         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
       end
     end
   end

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

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:absent, :present, nil] Whether the module should be present in the blacklist 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 [Object, nil] If specified, use this blacklist file instead of C(/etc/modprobe.d/blacklist-ansible.conf).
         attribute :blacklist_file

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

@@ -24,11 +24,11 @@ module Ansible
 
         # @return [:yes, :no, nil] Hash the hostname in the known_hosts file
         attribute :hash_host
-        validates :hash_host, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :hash_host, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:present, :absent, nil] I(present) to add the host key, I(absent) to remove it.
         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/locale_gen.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:absent, :present, nil] Whether the locale shall be 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
       end
     end
   end

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

@@ -28,11 +28,11 @@ module Ansible
 
         # @return [:absent, :present, nil] Control if the volume group exists.
         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 C(yes), allows to remove volume group with logical volumes.
         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
       end
     end
   end

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

@@ -22,15 +22,15 @@ module Ansible
 
         # @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 [:yes, :no, nil] Whether the volume is activate and visible to the host.
         attribute :active
-        validates :active, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :active, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Shrink or remove operations of volumes requires this switch. Ensures that that filesystems get never corrupted/destroyed by mistake.
         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 [String, nil] Free-form options to be passed to the lvcreate command.
         attribute :opts
@@ -50,11 +50,11 @@ module Ansible
 
         # @return [:yes, :no, nil] Shrink if current size is higher than size requested.
         attribute :shrink
-        validates :shrink, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :shrink, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Resize the underlying filesystem together with the logical volume.
         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
       end
     end
   end

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

@@ -10,27 +10,27 @@ module Ansible
       class Mksysb < Base
         # @return [:yes, :no, nil] Backup encrypted files.
         attribute :backup_crypt_files
-        validates :backup_crypt_files, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :backup_crypt_files, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Back up DMAPI filesystem files.
         attribute :backup_dmapi_fs
-        validates :backup_dmapi_fs, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :backup_dmapi_fs, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Creates a new MAP files.
         attribute :create_map_files
-        validates :create_map_files, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :create_map_files, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Excludes files using C(/etc/rootvg.exclude).
         attribute :exclude_files
-        validates :exclude_files, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :exclude_files, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Excludes WPAR files.
         attribute :exclude_wpar_files
-        validates :exclude_wpar_files, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :exclude_wpar_files, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Backup extended attributes.
         attribute :extended_attrs
-        validates :extended_attrs, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :extended_attrs, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String] Backup name
         attribute :name
@@ -38,11 +38,11 @@ module Ansible
 
         # @return [:yes, :no, nil] Creates a new file data.
         attribute :new_image_data
-        validates :new_image_data, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :new_image_data, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Exclude files from packing option listed in C(/etc/exclude_packing.rootvg).
         attribute :software_packing
-        validates :software_packing, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :software_packing, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String] Storage path where the mksysb will stored.
         attribute :storage_path
@@ -50,7 +50,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Creates backup using snapshots.
         attribute :use_snapshot
-        validates :use_snapshot, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :use_snapshot, 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/modprobe.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:absent, :present, nil] Whether the module should be 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] Modules parameters.
         attribute :params

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

@@ -34,7 +34,7 @@ module Ansible
 
         # @return [:absent, :mounted, :present, :unmounted] If C(mounted), the device will be actively mounted and appropriately configured in I(fstab). If the mount point is not present, the mount point will be created.,If C(unmounted), the device will be unmounted without changing I(fstab).,C(present) only specifies that the device is to be configured in I(fstab) and does not trigger or require a mount.,C(absent) specifies that the device mount's entry will be removed from I(fstab) and will also unmount the device and remove the mount point.
         attribute :state
-        validates :state, presence: true, inclusion: {:in=>[:absent, :mounted, :present, :unmounted], :message=>"%{value} needs to be :absent, :mounted, :present, :unmounted"}
+        validates :state, presence: true, expression_inclusion: {:in=>[:absent, :mounted, :present, :unmounted], :message=>"%{value} needs to be :absent, :mounted, :present, :unmounted"}
 
         # @return [String, nil] File to use instead of C(/etc/fstab). You shouldn't use this option unless you really know what you are doing. This might be useful if you need to configure mountpoints in a chroot environment.  OpenBSD does not allow specifying alternate fstab files with mount so do not use this on OpenBSD with any state that operates on the live filesystem.
         attribute :fstab
@@ -42,11 +42,11 @@ module Ansible
 
         # @return [:yes, :no, nil] Determines if the filesystem should be mounted on boot.,Only applies to Solaris systems.
         attribute :boot
-        validates :boot, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :boot, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @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
       end
     end
   end

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

@@ -15,7 +15,7 @@ module Ansible
 
         # @return [:started, :stopped, :reset, :restarted, :reloaded, nil] C(started)/C(stopped) are idempotent actions that will not run commands unless necessary. C(restarted) will always bounce the service. C(reloaded) will send a SIGHUP or start the service. C(reset) will start or stop the service according to whether it is enabled or not.
         attribute :state
-        validates :state, inclusion: {:in=>[:started, :stopped, :reset, :restarted, :reloaded], :message=>"%{value} needs to be :started, :stopped, :reset, :restarted, :reloaded"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:started, :stopped, :reset, :restarted, :reloaded], :message=>"%{value} needs to be :started, :stopped, :reset, :restarted, :reloaded"}, allow_nil: true
 
         # @return [Symbol, nil] Enable or disable the service, independently of C(*.preset) file preference or running state. Mutually exclusive with I(preset). Will take effect prior to I(state=reset).
         attribute :enabled
@@ -27,7 +27,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Run system-control talking to the calling user's service manager, rather than the system-wide service manager.
         attribute :user
-        validates :user, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :user, 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/openwrt_init.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:started, :stopped, :restarted, :reloaded, nil] C(started)/C(stopped) are idempotent actions that will not run commands unless necessary. C(restarted) will always bounce the service. C(reloaded) will always reload.
         attribute :state
-        validates :state, inclusion: {:in=>[:started, :stopped, :restarted, :reloaded], :message=>"%{value} needs to be :started, :stopped, :restarted, :reloaded"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:started, :stopped, :restarted, :reloaded], :message=>"%{value} needs to be :started, :stopped, :restarted, :reloaded"}, allow_nil: true
 
         # @return [Symbol, nil] Whether the service should start on boot. B(At least one of state and enabled are required.)
         attribute :enabled

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

@@ -22,19 +22,19 @@ module Ansible
 
         # @return [:array, :bool, :boolean, :date, :float, :int, :integer, :string, nil] The type of value to write.
         attribute :type
-        validates :type, inclusion: {:in=>[:array, :bool, :boolean, :date, :float, :int, :integer, :string], :message=>"%{value} needs to be :array, :bool, :boolean, :date, :float, :int, :integer, :string"}, allow_nil: true
+        validates :type, expression_inclusion: {:in=>[:array, :bool, :boolean, :date, :float, :int, :integer, :string], :message=>"%{value} needs to be :array, :bool, :boolean, :date, :float, :int, :integer, :string"}, allow_nil: true
 
         # @return [:yes, :no, nil] Add new elements to the array for a key which has an array as its value.
         attribute :array_add
-        validates :array_add, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :array_add, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Boolean, nil] The value to write. Only required when state = present.
         attribute :value
-        validates :value, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :value, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [:present, :absent, nil] The state of the user defaults
         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/pam_limits.rb

@@ -14,11 +14,11 @@ module Ansible
 
         # @return [:hard, :soft, :-] Limit type, see C(man 5 limits.conf) for an explanation
         attribute :limit_type
-        validates :limit_type, presence: true, inclusion: {:in=>[:hard, :soft, :-], :message=>"%{value} needs to be :hard, :soft, :-"}
+        validates :limit_type, presence: true, expression_inclusion: {:in=>[:hard, :soft, :-], :message=>"%{value} needs to be :hard, :soft, :-"}
 
         # @return [:core, :data, :fsize, :memlock, :nofile, :rss, :stack, :cpu, :nproc, :as, :maxlogins, :maxsyslogins, :priority, :locks, :sigpending, :msgqueue, :nice, :rtprio, :chroot] The limit to be set
         attribute :limit_item
-        validates :limit_item, presence: true, inclusion: {:in=>[:core, :data, :fsize, :memlock, :nofile, :rss, :stack, :cpu, :nproc, :as, :maxlogins, :maxsyslogins, :priority, :locks, :sigpending, :msgqueue, :nice, :rtprio, :chroot], :message=>"%{value} needs to be :core, :data, :fsize, :memlock, :nofile, :rss, :stack, :cpu, :nproc, :as, :maxlogins, :maxsyslogins, :priority, :locks, :sigpending, :msgqueue, :nice, :rtprio, :chroot"}
+        validates :limit_item, presence: true, expression_inclusion: {:in=>[:core, :data, :fsize, :memlock, :nofile, :rss, :stack, :cpu, :nproc, :as, :maxlogins, :maxsyslogins, :priority, :locks, :sigpending, :msgqueue, :nice, :rtprio, :chroot], :message=>"%{value} needs to be :core, :data, :fsize, :memlock, :nofile, :rss, :stack, :cpu, :nproc, :as, :maxlogins, :maxsyslogins, :priority, :locks, :sigpending, :msgqueue, :nice, :rtprio, :chroot"}
 
         # @return [Integer, String] The value of the limit.
         attribute :value
@@ -26,15 +26,15 @@ 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 [:yes, :no, nil] If set to C(yes), the minimal value will be used or conserved. If the specified value is inferior to the value in the file, file content is replaced with the new value, else content is not modified.
         attribute :use_min
-        validates :use_min, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :use_min, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] If set to C(yes), the maximal value will be used or conserved. If the specified value is superior to the value in the file, file content is replaced with the new value, else content is not modified.
         attribute :use_max
-        validates :use_max, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :use_max, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] Modify the limits.conf path.
         attribute :dest

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

@@ -42,7 +42,7 @@ module Ansible
 
         # @return [:updated, :before, :after, :args_present, :args_absent, :absent, nil] The default of 'updated' will modify an existing rule if type, control and module_path all match an existing rule.  With 'before', the new rule will be inserted before a rule matching type, control and module_path.  Similarly, with 'after', the new rule will be inserted after an existing rule matching type, control and module_path.  With either 'before' or 'after' new_type, new_control, and new_module_path must all be specified.  If state is 'args_absent' or 'args_present', new_type, new_control, and new_module_path will be ignored.  State 'absent' will remove the rule.  The 'absent' state was added in version 2.4 and is only available in Ansible versions >= 2.4.
         attribute :state
-        validates :state, inclusion: {:in=>[:updated, :before, :after, :args_present, :args_absent, :absent], :message=>"%{value} needs to be :updated, :before, :after, :args_present, :args_absent, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:updated, :before, :after, :args_present, :args_absent, :absent], :message=>"%{value} needs to be :updated, :before, :after, :args_present, :args_absent, :absent"}, allow_nil: true
 
         # @return [String, nil] This is the path to the PAM service files
         attribute :path
@@ -50,7 +50,7 @@ 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
       end
     end
   end

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

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:none, :cylinder, :minimal, :optimal, nil] Set alignment for newly created partitions.
         attribute :align
-        validates :align, inclusion: {:in=>[:none, :cylinder, :minimal, :optimal], :message=>"%{value} needs to be :none, :cylinder, :minimal, :optimal"}, allow_nil: true
+        validates :align, expression_inclusion: {:in=>[:none, :cylinder, :minimal, :optimal], :message=>"%{value} needs to be :none, :cylinder, :minimal, :optimal"}, allow_nil: true
 
         # @return [Integer, String, nil] The number of the partition to work with or the number of the partition that will be created. Required when performing any action on the disk, except fetching information.
         attribute :number
@@ -22,15 +22,15 @@ module Ansible
 
         # @return [:s, :B, :KB, :KiB, :MB, :MiB, :GB, :GiB, :TB, :TiB, :%, :cyl, :chs, :compact, nil] Selects the current default unit that Parted will use to display locations and capacities on the disk and to interpret those given by the user if they are not suffixed by an unit. When fetching information about a disk, it is always recommended to specify a unit.
         attribute :unit
-        validates :unit, inclusion: {:in=>[:s, :B, :KB, :KiB, :MB, :MiB, :GB, :GiB, :TB, :TiB, :%, :cyl, :chs, :compact], :message=>"%{value} needs to be :s, :B, :KB, :KiB, :MB, :MiB, :GB, :GiB, :TB, :TiB, :%, :cyl, :chs, :compact"}, allow_nil: true
+        validates :unit, expression_inclusion: {:in=>[:s, :B, :KB, :KiB, :MB, :MiB, :GB, :GiB, :TB, :TiB, :%, :cyl, :chs, :compact], :message=>"%{value} needs to be :s, :B, :KB, :KiB, :MB, :MiB, :GB, :GiB, :TB, :TiB, :%, :cyl, :chs, :compact"}, allow_nil: true
 
         # @return [:aix, :amiga, :bsd, :dvh, :gpt, :loop, :mac, :msdos, :pc98, :sun, nil] Creates a new disk label.
         attribute :label
-        validates :label, inclusion: {:in=>[:aix, :amiga, :bsd, :dvh, :gpt, :loop, :mac, :msdos, :pc98, :sun], :message=>"%{value} needs to be :aix, :amiga, :bsd, :dvh, :gpt, :loop, :mac, :msdos, :pc98, :sun"}, allow_nil: true
+        validates :label, expression_inclusion: {:in=>[:aix, :amiga, :bsd, :dvh, :gpt, :loop, :mac, :msdos, :pc98, :sun], :message=>"%{value} needs to be :aix, :amiga, :bsd, :dvh, :gpt, :loop, :mac, :msdos, :pc98, :sun"}, allow_nil: true
 
         # @return [:primary, :extended, :logical, nil] Is one of 'primary', 'extended' or 'logical' and may be specified only with 'msdos' or 'dvh' partition tables. A name must be specified for a 'gpt' partition table. Neither part-type nor name may be used with a 'sun' partition table.
         attribute :part_type
-        validates :part_type, inclusion: {:in=>[:primary, :extended, :logical], :message=>"%{value} needs to be :primary, :extended, :logical"}, allow_nil: true
+        validates :part_type, expression_inclusion: {:in=>[:primary, :extended, :logical], :message=>"%{value} needs to be :primary, :extended, :logical"}, allow_nil: true
 
         # @return [String, nil] Where the partition will start as offset from the beginning of the disk, that is, the "distance" from the start of the disk. The distance can be specified with all the units supported by parted (except compat) and it is case sensitive. E.g. C(10GiB), C(15%).
         attribute :part_start
@@ -49,7 +49,7 @@ module Ansible
 
         # @return [:present, :absent, :info, nil] If to create or delete a partition. If set to C(info) the module will only return the device information.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent, :info], :message=>"%{value} needs to be :present, :absent, :info"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent, :info], :message=>"%{value} needs to be :present, :absent, :info"}, allow_nil: true
       end
     end
   end

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

@@ -36,7 +36,7 @@ module Ansible
 
         # @return [:stdout, :syslog, :all, nil] Where the puppet logs should go, if puppet apply is being used. C(all)\r\nwill go to both C(stdout) and C(syslog).\r\n
         attribute :logdest
-        validates :logdest, inclusion: {:in=>[:stdout, :syslog, :all], :message=>"%{value} needs to be :stdout, :syslog, :all"}, allow_nil: true
+        validates :logdest, expression_inclusion: {:in=>[:stdout, :syslog, :all], :message=>"%{value} needs to be :stdout, :syslog, :all"}, allow_nil: true
 
         # @return [String, nil] The name to use when handling certificates.
         attribute :certname

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

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:killed, :once, :reloaded, :restarted, :started, :stopped, nil] C(started)/C(stopped) are idempotent actions that will not run commands unless necessary.  C(restarted) will always bounce the service (sv restart) and C(killed) will always bounce the service (sv force-stop). C(reloaded) will send a HUP (sv reload). C(once) will run a normally downed sv once (sv once), not really an idempotent operation.
         attribute :state
-        validates :state, inclusion: {:in=>[:killed, :once, :reloaded, :restarted, :started, :stopped], :message=>"%{value} needs to be :killed, :once, :reloaded, :restarted, :started, :stopped"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:killed, :once, :reloaded, :restarted, :started, :stopped], :message=>"%{value} needs to be :killed, :once, :reloaded, :restarted, :started, :stopped"}, allow_nil: true
 
         # @return [Symbol, nil] Whether the service is enabled or not, if disabled it also implies stopped.
         attribute :enabled

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

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Set to C(yes) if the boolean setting should survive a reboot.
         attribute :persistent
-        validates :persistent, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :persistent, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Symbol] Desired boolean value
         attribute :state

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

@@ -35,7 +35,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Reload SELinux policy after commit.,Note that this does not apply SELinux file contexts to existing files.
         attribute :reload
-        validates :reload, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :reload, 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/selinux.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:enforcing, :permissive, :disabled] The SELinux mode
         attribute :state
-        validates :state, presence: true, inclusion: {:in=>[:enforcing, :permissive, :disabled], :message=>"%{value} needs to be :enforcing, :permissive, :disabled"}
+        validates :state, presence: true, expression_inclusion: {:in=>[:enforcing, :permissive, :disabled], :message=>"%{value} needs to be :enforcing, :permissive, :disabled"}
 
         # @return [String, nil] path to the SELinux configuration file, if non-standard
         attribute :conf

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

@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:yes, :no, nil] automatically reload the policy after a change,default is set to 'false' as that's what most people would want after changing one domain,Note that this doesn't work on older version of the library (example EL 6), the module will silently ignore it in this case
         attribute :no_reload
-        validates :no_reload, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :no_reload, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Object, nil] name of the SELinux policy store to use
         attribute :store

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

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:tcp, :udp] Protocol for the specified port.
         attribute :proto
-        validates :proto, presence: true, inclusion: {:in=>[:tcp, :udp], :message=>"%{value} needs to be :tcp, :udp"}
+        validates :proto, presence: true, expression_inclusion: {:in=>[:tcp, :udp], :message=>"%{value} needs to be :tcp, :udp"}
 
         # @return [String] SELinux type for the specified port.
         attribute :setype
@@ -22,11 +22,11 @@ module Ansible
 
         # @return [:absent, :present] Desired boolean value.
         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 [:yes, :no, nil] Reload SELinux policy after commit.
         attribute :reload
-        validates :reload, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :reload, 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/service.rb

@@ -15,7 +15,7 @@ module Ansible
 
         # @return [:reloaded, :restarted, :started, :stopped, nil] C(started)/C(stopped) are idempotent actions that will not run commands unless necessary.  C(restarted) will always bounce the service.  C(reloaded) will always reload. B(At least one of state and enabled are required.) Note that reloaded will start the service if it is not already started, even if your chosen init system wouldn't normally.
         attribute :state
-        validates :state, inclusion: {:in=>[:reloaded, :restarted, :started, :stopped], :message=>"%{value} needs to be :reloaded, :restarted, :started, :stopped"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:reloaded, :restarted, :started, :stopped], :message=>"%{value} needs to be :reloaded, :restarted, :started, :stopped"}, allow_nil: true
 
         # @return [Object, nil] If the service is being C(restarted) then sleep this many seconds between the stop and start command. This helps to workaround badly behaving init scripts that exit immediately after signaling a process to stop.
         attribute :sleep

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

@@ -10,7 +10,7 @@ module Ansible
       class Solaris_zone < Base
         # @return [:absent, :attached, :configured, :detached, :installed, :present, :running, :started, :stopped] C(present), configure and install the zone.,C(installed), synonym for C(present).,C(running), if the zone already exists, boot it, otherwise, configure and install the zone first, then boot it.,C(started), synonym for C(running).,C(stopped), shutdown a zone.,C(absent), destroy the zone.,C(configured), configure the ready so that it's to be attached.,C(attached), attach a zone, but do not boot it.,C(detached), shutdown and detach a zone
         attribute :state
-        validates :state, presence: true, inclusion: {:in=>[:absent, :attached, :configured, :detached, :installed, :present, :running, :started, :stopped], :message=>"%{value} needs to be :absent, :attached, :configured, :detached, :installed, :present, :running, :started, :stopped"}
+        validates :state, presence: true, expression_inclusion: {:in=>[:absent, :attached, :configured, :detached, :installed, :present, :running, :started, :stopped], :message=>"%{value} needs to be :absent, :attached, :configured, :detached, :installed, :present, :running, :started, :stopped"}
 
         # @return [String] Zone name.
         attribute :name
@@ -22,7 +22,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Whether to create a sparse (C(true)) or whole root (C(false)) zone.
         attribute :sparse
-        validates :sparse, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :sparse, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] The password hash for the root account. If not specified, the zone's root account will not have a password.
         attribute :root_password