ansible-ruby 1.0.22 → 1.0.23

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

@@ -14,11 +14,11 @@ 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 svc (svc -t) and C(killed) will always bounce the svc (svc -k). C(reloaded) will send a sigusr1 (svc -1). C(once) will run a normally downed svc once (svc -o), 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 [:yes, :no, nil] Should a 'down' file exist or not, if it exists it disables auto startup. defaults to no. Downed does not imply stopped.
         attribute :downed
-        validates :downed, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :downed, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Symbol, nil] Wheater the service is enabled or not, if disabled it also implies stopped. Make note that a service can be enabled and downed (no auto restart).
         attribute :enabled

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

@@ -18,15 +18,15 @@ module Ansible
 
         # @return [:present, :absent, nil] Whether the entry should be present or absent in the sysctl 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 [:yes, :no, nil] Use this option to ignore errors about unknown keys.
         attribute :ignoreerrors
-        validates :ignoreerrors, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :ignoreerrors, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] If C(yes), performs a I(/sbin/sysctl -p) if the C(sysctl_file) is updated. If C(no), does not reload I(sysctl) even if the C(sysctl_file) is updated.
         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
 
         # @return [String, nil] Specifies the absolute path to C(sysctl.conf), if not C(/etc/sysctl.conf).
         attribute :sysctl_file
@@ -34,7 +34,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Verify token value with the sysctl command and set with -w if necessary
         attribute :sysctl_set
-        validates :sysctl_set, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :sysctl_set, 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/systemd.rb

@@ -14,7 +14,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.
         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 [Symbol, nil] Whether the service should start on boot. B(At least one of state and enabled are required.)
         attribute :enabled
@@ -30,19 +30,19 @@ module Ansible
 
         # @return [:yes, :no, nil] run daemon-reload before doing any other operations, to make sure systemd has read any changes.
         attribute :daemon_reload
-        validates :daemon_reload, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :daemon_reload, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] (deprecated) run ``systemctl`` talking to the service manager of the calling user, rather than the service manager of the system.,This option is deprecated and will eventually be removed in 2.11. The ``scope`` option should be used instead.
         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
 
         # @return [:system, :user, :global, nil] run systemctl within a given service manager scope, either as the default system scope (system), the current user's scope (user), or the scope of all users (global).
         attribute :scope
-        validates :scope, inclusion: {:in=>[:system, :user, :global], :message=>"%{value} needs to be :system, :user, :global"}, allow_nil: true
+        validates :scope, expression_inclusion: {:in=>[:system, :user, :global], :message=>"%{value} needs to be :system, :user, :global"}, allow_nil: true
 
         # @return [:yes, :no, nil] Do not synchronously wait for the requested operation to finish. Enqueued job will continue without Ansible blocking on its completion.
         attribute :no_block
-        validates :no_block, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :no_block, 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/sysvinit.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. Not all init scripts support C(restarted) nor C(reloaded) natively, so these will both trigger a stop and start as needed.
         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/timezone.rb

@@ -19,7 +19,7 @@ module Ansible
 
         # @return [:UTC, :local, nil] Whether the hardware clock is in UTC or in local timezone. Default is to keep current setting. Note that this option is recommended not to change and may fail to configure, especially on virtual environments such as AWS. B(At least one of name and hwclock are required.) I(Only used on Linux.)
         attribute :hwclock
-        validates :hwclock, inclusion: {:in=>[:UTC, :local], :message=>"%{value} needs to be :UTC, :local"}, allow_nil: true
+        validates :hwclock, expression_inclusion: {:in=>[:UTC, :local], :message=>"%{value} needs to be :UTC, :local"}, allow_nil: true
       end
     end
   end

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

@@ -10,26 +10,26 @@ module Ansible
       class Ufw < Base
         # @return [:disabled, :enabled, :reloaded, :reset, nil] C(enabled) reloads firewall and enables firewall on boot.,C(disabled) unloads firewall and disables firewall on boot.,C(reloaded) reloads firewall.,C(reset) disables and resets firewall to installation defaults.
         attribute :state
-        validates :state, inclusion: {:in=>[:disabled, :enabled, :reloaded, :reset], :message=>"%{value} needs to be :disabled, :enabled, :reloaded, :reset"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:disabled, :enabled, :reloaded, :reset], :message=>"%{value} needs to be :disabled, :enabled, :reloaded, :reset"}, allow_nil: true
 
         # @return [:allow, :deny, :reject, nil] Change the default policy for incoming or outgoing traffic.
         attribute :policy
-        validates :policy, inclusion: {:in=>[:allow, :deny, :reject], :message=>"%{value} needs to be :allow, :deny, :reject"}, allow_nil: true
+        validates :policy, expression_inclusion: {:in=>[:allow, :deny, :reject], :message=>"%{value} needs to be :allow, :deny, :reject"}, allow_nil: true
 
         # @return [:in, :incoming, :out, :outgoing, :routed, nil] Select direction for a rule or default policy command.
         attribute :direction
-        validates :direction, inclusion: {:in=>[:in, :incoming, :out, :outgoing, :routed], :message=>"%{value} needs to be :in, :incoming, :out, :outgoing, :routed"}, allow_nil: true
+        validates :direction, expression_inclusion: {:in=>[:in, :incoming, :out, :outgoing, :routed], :message=>"%{value} needs to be :in, :incoming, :out, :outgoing, :routed"}, allow_nil: true
 
         # @return [:low, :medium, :high, :full, Boolean, nil] Toggles logging. Logged packets use the LOG_KERN syslog facility.
         attribute :logging
-        validates :logging, inclusion: {:in=>[true, false, :low, :medium, :high, :full], :message=>"%{value} needs to be true, false, :low, :medium, :high, :full"}, allow_nil: true
+        validates :logging, expression_inclusion: {:in=>[true, false, :low, :medium, :high, :full], :message=>"%{value} needs to be true, false, :low, :medium, :high, :full"}, allow_nil: true
 
         # @return [Object, nil] Insert the corresponding rule as rule number NUM
         attribute :insert
 
         # @return [:allow, :deny, :limit, :reject, nil] Add firewall rule
         attribute :rule
-        validates :rule, inclusion: {:in=>[:allow, :deny, :limit, :reject], :message=>"%{value} needs to be :allow, :deny, :limit, :reject"}, allow_nil: true
+        validates :rule, expression_inclusion: {:in=>[:allow, :deny, :limit, :reject], :message=>"%{value} needs to be :allow, :deny, :limit, :reject"}, allow_nil: true
 
         # @return [Symbol, nil] Log new connections matched to this rule
         attribute :log
@@ -53,7 +53,7 @@ module Ansible
 
         # @return [:any, :tcp, :udp, :ipv6, :esp, :ah, nil] TCP/IP protocol.
         attribute :proto
-        validates :proto, inclusion: {:in=>[:any, :tcp, :udp, :ipv6, :esp, :ah], :message=>"%{value} needs to be :any, :tcp, :udp, :ipv6, :esp, :ah"}, allow_nil: true
+        validates :proto, expression_inclusion: {:in=>[:any, :tcp, :udp, :ipv6, :esp, :ah], :message=>"%{value} needs to be :any, :tcp, :udp, :ipv6, :esp, :ah"}, allow_nil: true
 
         # @return [String, nil] Use profile located in C(/etc/ufw/applications.d).
         attribute :name

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

@@ -27,7 +27,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Optionally when used with the -u option, this option allows to change the user ID to a non-unique value.
         attribute :non_unique
-        validates :non_unique, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :non_unique, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Object, nil] Optionally sets the seuser type (user_u) on selinux enabled systems.
         attribute :seuser
@@ -42,7 +42,7 @@ module Ansible
 
         # @return [:yes, :no, nil] If C(yes), add the user to the groups specified in C(groups).,If C(no), user will only be added to the groups specified in C(groups), removing them from all other groups.
         attribute :append
-        validates :append, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :append, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] Optionally set the user's shell.,On macOS, before version 2.5, the default shell for non-system users was /usr/bin/false. Since 2.5, the default shell for non-system users on macOS is /bin/bash.,On other operating systems, the default shell is determined by the underlying tool being used. See Notes for details.
         attribute :shell
@@ -59,34 +59,34 @@ module Ansible
 
         # @return [:absent, :present, nil] Whether the account should exist or not, taking action if the state is different from what is stated.
         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] Unless set to C(no), a home directory will be made for the user when the account is created or if the home directory does not exist.,Changed from C(createhome) to C(create_home) in version 2.5.
         attribute :create_home
-        validates :create_home, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :create_home, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] If set to C(yes) when used with C(home=), attempt to move the user's old home directory to the specified directory if it isn't there already and the old home exists.
         attribute :move_home
-        validates :move_home, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :move_home, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] When creating an account C(state=present), setting this to C(yes) makes the user a system account. This setting cannot be changed on existing users.
         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 [:yes, :no, nil] This only affects C(state=absent), it forces removal of the user and associated directories on supported platforms. The behavior is the same as C(userdel --force), check the man page for C(userdel) on your system for details and support.
         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] This only affects C(state=absent), it attempts to remove directories associated with the user. The behavior is the same as C(userdel --remove), check the man page for details and support.
         attribute :remove
-        validates :remove, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :remove, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Object, nil] Optionally sets the user's login class, a feature of most BSD OSs.
         attribute :login_class
 
         # @return [:yes, :no, nil] Whether to generate a SSH key for the user in question. This will B(not) overwrite an existing SSH key.
         attribute :generate_ssh_key
-        validates :generate_ssh_key, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :generate_ssh_key, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] Optionally specify number of bits in SSH key to create.
         attribute :ssh_key_bits
@@ -109,7 +109,7 @@ module Ansible
 
         # @return [:always, :on_create, nil] C(always) will update passwords if they differ.  C(on_create) will only set the password for newly created users.
         attribute :update_password
-        validates :update_password, inclusion: {:in=>[:always, :on_create], :message=>"%{value} needs to be :always, :on_create"}, allow_nil: true
+        validates :update_password, expression_inclusion: {:in=>[:always, :on_create], :message=>"%{value} needs to be :always, :on_create"}, allow_nil: true
 
         # @return [Integer, nil] An expiry time for the user in epoch, it will be ignored on platforms that do not support this. Currently supported on GNU/Linux, FreeBSD, and DragonFlyBSD.,Since version 2.6 you can remove the expiry time specify a negative value. Currently supported on GNU/Linux and FreeBSD.
         attribute :expires
@@ -121,7 +121,7 @@ module Ansible
 
         # @return [:yes, :no, 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 users. I.E. it uses `luseradd` instead of `useradd`.,This requires that these commands exist on the targeted host, otherwise it will be a fatal error.
         attribute :local
-        validates :local, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :local, 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/vdo.rb

@@ -14,15 +14,15 @@ module Ansible
 
         # @return [:present, :absent] Whether this VDO volume should be "present" or "absent". If a "present" VDO volume does not exist, it will be created.  If a "present" VDO volume already exists, it will be modified, by updating the configuration, which will take effect when the VDO volume is restarted. Not all parameters of an existing VDO volume can be modified; the "statusparamkeys" list contains the parameters that can be modified after creation. If an "absent" VDO volume does not exist, it will not be removed.
         attribute :state
-        validates :state, presence: true, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}
+        validates :state, presence: true, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}
 
         # @return [:yes, :no, nil] The "activate" status for a VDO volume.  If this is set to "no", the VDO volume cannot be started, and it will not start on system startup.  However, on initial creation, a VDO volume with "activated" set to "off" will be running, until stopped.  This is the default behavior of the "vdo create" command; it provides the user an opportunity to write a base amount of metadata (filesystem, LVM headers, etc.) to the VDO volume prior to stopping the volume, and leaving it deactivated until ready to use.
         attribute :activated
-        validates :activated, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :activated, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Whether this VDO volume is running.  A VDO volume must be activated in order to be started.
         attribute :running
-        validates :running, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :running, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] The full path of the device to use for VDO storage. This is required if "state" is "present".
         attribute :device
@@ -34,18 +34,18 @@ module Ansible
 
         # @return [:enabled, :disabled, nil] Configures whether deduplication is enabled.  The default for a created volume is 'enabled'.  Existing volumes will maintain their previously configured setting unless a different value is specified in the playbook.
         attribute :deduplication
-        validates :deduplication, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :deduplication, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [:enabled, :disabled, nil] Configures whether compression is enabled.  The default for a created volume is 'enabled'.  Existing volumes will maintain their previously configured setting unless a different value is specified in the playbook.
         attribute :compression
-        validates :compression, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :compression, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [Object, nil] The amount of memory allocated for caching block map pages, in megabytes (or may be issued with an LVM-style suffix of K, M, G, or T).  The default (and minimum) value is 128M.  The value specifies the size of the cache; there is a 15% memory usage overhead. Each 1.25G of block map covers 1T of logical blocks, therefore a small amount of block map cache memory can cache a significantly large amount of block map data.  Existing volumes will maintain their previously configured setting unless a different value is specified in the playbook.
         attribute :blockmapcachesize
 
         # @return [:enabled, :disabled, nil] Enables or disables the read cache.  The default is 'disabled'.  Choosing 'enabled' enables a read cache which may improve performance for workloads of high deduplication, read workloads with a high level of compression, or on hard disk storage.  Existing volumes will maintain their previously configured setting unless a different value is specified in the playbook.
         attribute :readcache
-        validates :readcache, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :readcache, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [Object, nil] Specifies the extra VDO device read cache size in megabytes.  This is in addition to a system-defined minimum.  Using a value with a suffix of K, M, G, or T is optional.  The default value is 0.  1.125 MB of memory per bio thread will be used per 1 MB of read cache specified (for example, a VDO volume configured with 4 bio threads will have a read cache memory usage overhead of 4.5 MB per 1 MB of read cache specified). Existing volumes will maintain their previously configured setting unless a different value is specified in the playbook.
         attribute :readcachesize
@@ -63,7 +63,7 @@ module Ansible
 
         # @return [:auto, :sync, :async, nil] Specifies the write policy of the VDO volume.  The 'sync' mode acknowledges writes only after data is on stable storage.  The 'async' mode acknowledges writes when data has been cached for writing to stable storage.  The default (and highly recommended) 'auto' mode checks the storage device to determine whether it supports flushes.  Devices that support flushes will result in a VDO volume in 'async' mode, while devices that do not support flushes will run in sync mode. Existing volumes will maintain their previously configured setting unless a different value is specified in the playbook.
         attribute :writepolicy
-        validates :writepolicy, inclusion: {:in=>[:auto, :sync, :async], :message=>"%{value} needs to be :auto, :sync, :async"}, allow_nil: true
+        validates :writepolicy, expression_inclusion: {:in=>[:auto, :sync, :async], :message=>"%{value} needs to be :auto, :sync, :async"}, allow_nil: true
 
         # @return [Object, nil] Specifies the amount of index memory in gigabytes.  The default is 0.25.  The special decimal values 0.25, 0.5, and 0.75 can be used, as can any positive integer. This option is only available when creating a new volume, and cannot be changed for an existing volume.
         attribute :indexmem

data/lib/ansible/ruby/modules/generated/utilities/helper/meta.rb

@@ -11,7 +11,7 @@ module Ansible
       class Meta < Base
         # @return [:flush_handlers, :refresh_inventory, :noop, :clear_facts, :clear_host_errors, :end_play, :reset_connection] This module takes a free form command, as a string. There's not an actual option named "free form".  See the examples!,C(flush_handlers) makes Ansible run any handler tasks which have thus far been notified. Ansible inserts these tasks internally at certain points to implicitly trigger handler runs (after pre/post tasks, the final role execution, and the main tasks section of your plays).\r\n,C(refresh_inventory) (added in 2.0) forces the reload of the inventory, which in the case of dynamic inventory scripts means they will be re-executed. If the dynamic inventory script is using a cache, Ansible cannot know this and has no way of refreshing it (you can disable the cache or, if available for your specific inventory datasource (for es.: aws), you can use the an inventory plugin instead of an inventory script). This is mainly useful when additional hosts are created and users wish to use them instead of using the `add_host` module."\r\n,C(noop) (added in 2.0) This literally does 'nothing'. It is mainly used internally and not recommended for general use.,C(clear_facts) (added in 2.1) causes the gathered facts for the hosts specified in the play's list of hosts to be cleared, including the fact cache.,C(clear_host_errors) (added in 2.1) clears the failed state (if any) from hosts specified in the play's list of hosts.,C(end_play) (added in 2.2) causes the play to end without failing the host(s). Note that this affects all hosts.,C(reset_connection) (added in 2.3) interrupts a persistent connection (i.e. ssh + control persist)
         attribute :free_form
-        validates :free_form, presence: true, inclusion: {:in=>[:flush_handlers, :refresh_inventory, :noop, :clear_facts, :clear_host_errors, :end_play, :reset_connection], :message=>"%{value} needs to be :flush_handlers, :refresh_inventory, :noop, :clear_facts, :clear_host_errors, :end_play, :reset_connection"}
+        validates :free_form, presence: true, expression_inclusion: {:in=>[:flush_handlers, :refresh_inventory, :noop, :clear_facts, :clear_host_errors, :end_play, :reset_connection], :message=>"%{value} needs to be :flush_handlers, :refresh_inventory, :noop, :clear_facts, :clear_host_errors, :end_play, :reset_connection"}
       end
     end
   end

data/lib/ansible/ruby/modules/generated/utilities/logic/async_status.rb

@@ -15,7 +15,7 @@ module Ansible
 
         # @return [:status, :cleanup, nil] if C(status), obtain the status; if C(cleanup), clean up the async job cache (by default in C(~/.ansible_async/)) for the specified job I(jid).
         attribute :mode
-        validates :mode, inclusion: {:in=>[:status, :cleanup], :message=>"%{value} needs to be :status, :cleanup"}, allow_nil: true
+        validates :mode, expression_inclusion: {:in=>[:status, :cleanup], :message=>"%{value} needs to be :status, :cleanup"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/utilities/logic/import_role.rb

@@ -27,11 +27,11 @@ module Ansible
 
         # @return [:yes, :no, nil] Overrides the role's metadata setting to allow using a role more than once with the same parameters.
         attribute :allow_duplicates
-        validates :allow_duplicates, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :allow_duplicates, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] This option is a no op, and the functionality described in previous versions was not implemented. This option will be removed in Ansible v2.8.
         attribute :private
-        validates :private, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :private, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/utilities/logic/include_role.rb

@@ -32,14 +32,14 @@ module Ansible
 
         # @return [:yes, :no, nil] Overrides the role's metadata setting to allow using a role more than once with the same parameters.
         attribute :allow_duplicates
-        validates :allow_duplicates, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :allow_duplicates, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Object, nil] This option is a no op, and the functionality described in previous versions was not implemented. This option will be removed in Ansible v2.8.
         attribute :private
 
         # @return [:yes, :no, nil] This option dictates whether the role's C(vars) and C(defaults) are exposed to the playbook. If set to C(yes) the variables will be available to tasks following the C(include_role) task. This functionality differs from standard variable exposure for roles listed under the C(roles) header or C(import_role) as they are exposed at playbook parsing time, and available to earlier roles and tasks as well.
         attribute :public
-        validates :public, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :public, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/utilities/logic/pause.rb

@@ -25,7 +25,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Controls whether or not keyboard input is shown when typing.,Has no effect if 'seconds' or 'minutes' is set.
         attribute :echo
-        validates :echo, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :echo, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/utilities/logic/set_fact.rb

@@ -17,7 +17,7 @@ module Ansible
 
         # @return [:yes, :no, nil] This boolean indicates if the facts set will also be added to the fact cache, if fact caching is enabled.
         attribute :cacheable
-        validates :cacheable, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :cacheable, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/utilities/logic/set_stats.rb

@@ -15,11 +15,11 @@ module Ansible
 
         # @return [Boolean, nil] boolean that indicates if the stats is per host or for all hosts in the run.
         attribute :per_host
-        validates :per_host, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :per_host, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Boolean, nil] boolean that indicates if the provided value is aggregated to the existing stat C(yes) or will replace it C(no)
         attribute :aggregate
-        validates :aggregate, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :aggregate, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/utilities/logic/wait_for.rb

@@ -39,7 +39,7 @@ module Ansible
 
         # @return [:absent, :drained, :present, :started, :stopped, nil] Either C(present), C(started), or C(stopped), C(absent), or C(drained).,When checking a port C(started) will ensure the port is open, C(stopped) will check that it is closed, C(drained) will check for active connections.,When checking for a file or a search string C(present) or C(started) will ensure that the file or string is present before continuing, C(absent) will check that file is absent or removed.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :drained, :present, :started, :stopped], :message=>"%{value} needs to be :absent, :drained, :present, :started, :stopped"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :drained, :present, :started, :stopped], :message=>"%{value} needs to be :absent, :drained, :present, :started, :stopped"}, allow_nil: true
 
         # @return [String, nil] Path to a file on the filesystem that must exist before continuing.
         attribute :path

data/lib/ansible/ruby/modules/generated/web_infrastructure/ansible_tower/tower_credential.rb

@@ -31,7 +31,7 @@ module Ansible
 
         # @return [:ssh, :vault, :net, :scm, :aws, :vmware, :satellite6, :cloudforms, :gce, :azure_rm, :openstack, :rhv, :insights, :tower] Type of credential being added.
         attribute :kind
-        validates :kind, presence: true, inclusion: {:in=>[:ssh, :vault, :net, :scm, :aws, :vmware, :satellite6, :cloudforms, :gce, :azure_rm, :openstack, :rhv, :insights, :tower], :message=>"%{value} needs to be :ssh, :vault, :net, :scm, :aws, :vmware, :satellite6, :cloudforms, :gce, :azure_rm, :openstack, :rhv, :insights, :tower"}
+        validates :kind, presence: true, expression_inclusion: {:in=>[:ssh, :vault, :net, :scm, :aws, :vmware, :satellite6, :cloudforms, :gce, :azure_rm, :openstack, :rhv, :insights, :tower], :message=>"%{value} needs to be :ssh, :vault, :net, :scm, :aws, :vmware, :satellite6, :cloudforms, :gce, :azure_rm, :openstack, :rhv, :insights, :tower"}
 
         # @return [Object, nil] Host for this credential.
         attribute :host
@@ -50,7 +50,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Should use authorize for net type.
         attribute :authorize
-        validates :authorize, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :authorize, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Object, nil] Password for net credentials that require authorize.
         attribute :authorize_password
@@ -75,7 +75,7 @@ module Ansible
 
         # @return [:None, :sudo, :su, :pbrun, :pfexec, :pmrun, nil] Become method to Use for privledge escalation.
         attribute :become_method
-        validates :become_method, inclusion: {:in=>[:None, :sudo, :su, :pbrun, :pfexec, :pmrun], :message=>"%{value} needs to be :None, :sudo, :su, :pbrun, :pfexec, :pmrun"}, allow_nil: true
+        validates :become_method, expression_inclusion: {:in=>[:None, :sudo, :su, :pbrun, :pfexec, :pmrun], :message=>"%{value} needs to be :None, :sudo, :su, :pbrun, :pfexec, :pmrun"}, allow_nil: true
 
         # @return [Object, nil] Become username. Use ASK for prompting.
         attribute :become_username
@@ -88,7 +88,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Desired state of the resource.
         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/web_infrastructure/ansible_tower/tower_credential_type.rb

@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:ssh, :vault, :net, :scm, :cloud, :insights, nil] The type of credential type being added. Note that only cloud and net can be used for creating credential types. Refer to the Ansible for more information.
         attribute :kind
-        validates :kind, inclusion: {:in=>[:ssh, :vault, :net, :scm, :cloud, :insights], :message=>"%{value} needs to be :ssh, :vault, :net, :scm, :cloud, :insights"}, allow_nil: true
+        validates :kind, expression_inclusion: {:in=>[:ssh, :vault, :net, :scm, :cloud, :insights], :message=>"%{value} needs to be :ssh, :vault, :net, :scm, :cloud, :insights"}, allow_nil: true
 
         # @return [String, nil] Enter inputs using either JSON or YAML syntax. Refer to the Ansible Tower documentation for example syntax.
         attribute :inputs
@@ -30,7 +30,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Desired state of the resource.
         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] Tower option to avoid certificates check.
         attribute :tower_verify_ssl

data/lib/ansible/ruby/modules/generated/web_infrastructure/ansible_tower/tower_group.rb

@@ -28,7 +28,7 @@ module Ansible
 
         # @return [:manual, :file, :ec2, :rax, :vmware, :gce, :azure, :azure_rm, :openstack, :satellite6, :cloudforms, :custom, nil] The source to use for this group.
         attribute :source
-        validates :source, inclusion: {:in=>[:manual, :file, :ec2, :rax, :vmware, :gce, :azure, :azure_rm, :openstack, :satellite6, :cloudforms, :custom], :message=>"%{value} needs to be :manual, :file, :ec2, :rax, :vmware, :gce, :azure, :azure_rm, :openstack, :satellite6, :cloudforms, :custom"}, allow_nil: true
+        validates :source, expression_inclusion: {:in=>[:manual, :file, :ec2, :rax, :vmware, :gce, :azure, :azure_rm, :openstack, :satellite6, :cloudforms, :custom], :message=>"%{value} needs to be :manual, :file, :ec2, :rax, :vmware, :gce, :azure, :azure_rm, :openstack, :satellite6, :cloudforms, :custom"}, allow_nil: true
 
         # @return [Object, nil] Regions for cloud provider.
         attribute :source_regions
@@ -47,18 +47,18 @@ module Ansible
 
         # @return [:yes, :no, nil] Delete child groups and hosts not found in source.
         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 [Object, nil] Override vars in child groups and hosts with those from external source.
         attribute :overwrite_vars
 
         # @return [:yes, :no, nil] Refresh inventory data from its source each time a job is run.
         attribute :update_on_launch
-        validates :update_on_launch, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :update_on_launch, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:present, :absent, nil] Desired state of the resource.
         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/web_infrastructure/ansible_tower/tower_host.rb

@@ -22,14 +22,14 @@ module Ansible
 
         # @return [:yes, :no, nil] If the host should be enabled.
         attribute :enabled
-        validates :enabled, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :enabled, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Object, nil] Variables to use for the host. Use C(@) for a file.
         attribute :variables
 
         # @return [:present, :absent, nil] Desired state of the resource.
         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