ansible-ruby 1.0.22 → 1.0.23

data/lib/ansible/ruby/modules/generated/database/proxysql/proxysql_backend_servers.rb

@@ -22,7 +22,7 @@ module Ansible
 
         # @return [:ONLINE, :OFFLINE_SOFT, :OFFLINE_HARD, nil] ONLINE - Backend server is fully operational. OFFLINE_SOFT - When a server is put into C(OFFLINE_SOFT) mode, connections are kept in use until the current transaction is completed. This allows to gracefully detach a backend. OFFLINE_HARD - When a server is put into C(OFFLINE_HARD) mode, the existing connections are dropped, while new incoming connections aren't accepted either.\r\nIf omitted the proxysql database default for I(status) is C(ONLINE).
         attribute :status
-        validates :status, inclusion: {:in=>[:ONLINE, :OFFLINE_SOFT, :OFFLINE_HARD], :message=>"%{value} needs to be :ONLINE, :OFFLINE_SOFT, :OFFLINE_HARD"}, allow_nil: true
+        validates :status, expression_inclusion: {:in=>[:ONLINE, :OFFLINE_SOFT, :OFFLINE_HARD], :message=>"%{value} needs to be :ONLINE, :OFFLINE_SOFT, :OFFLINE_HARD"}, allow_nil: true
 
         # @return [Object, nil] The bigger the weight of a server relative to other weights, the higher the probability of the server being chosen from the hostgroup. If omitted the proxysql database default for I(weight) is 1.
         attribute :weight
@@ -48,7 +48,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present) - adds the host, when C(absent) - removes the host.
         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/database/proxysql/proxysql_manage_config.rb

@@ -10,19 +10,19 @@ module Ansible
       class Proxysql_manage_config < Base
         # @return [:LOAD, :SAVE] The supplied I(action) combines with the supplied I(direction) to provide the semantics of how we want to move the I(config_settings) between the I(config_layers).
         attribute :action
-        validates :action, presence: true, inclusion: {:in=>[:LOAD, :SAVE], :message=>"%{value} needs to be :LOAD, :SAVE"}
+        validates :action, presence: true, expression_inclusion: {:in=>[:LOAD, :SAVE], :message=>"%{value} needs to be :LOAD, :SAVE"}
 
         # @return [:"MYSQL USERS", :"MYSQL SERVERS", :"MYSQL QUERY RULES", :"MYSQL VARIABLES", :"ADMIN VARIABLES", :SCHEDULER] The I(config_settings) specifies which configuration we're writing.
         attribute :config_settings
-        validates :config_settings, presence: true, inclusion: {:in=>[:"MYSQL USERS", :"MYSQL SERVERS", :"MYSQL QUERY RULES", :"MYSQL VARIABLES", :"ADMIN VARIABLES", :SCHEDULER], :message=>"%{value} needs to be :\"MYSQL USERS\", :\"MYSQL SERVERS\", :\"MYSQL QUERY RULES\", :\"MYSQL VARIABLES\", :\"ADMIN VARIABLES\", :SCHEDULER"}
+        validates :config_settings, presence: true, expression_inclusion: {:in=>[:"MYSQL USERS", :"MYSQL SERVERS", :"MYSQL QUERY RULES", :"MYSQL VARIABLES", :"ADMIN VARIABLES", :SCHEDULER], :message=>"%{value} needs to be :\"MYSQL USERS\", :\"MYSQL SERVERS\", :\"MYSQL QUERY RULES\", :\"MYSQL VARIABLES\", :\"ADMIN VARIABLES\", :SCHEDULER"}
 
         # @return [:FROM, :TO] FROM - denotes we're reading values FROM the supplied I(config_layer) and writing to the next layer. TO - denotes we're reading from the previous layer and writing TO the supplied I(config_layer)."
         attribute :direction
-        validates :direction, presence: true, inclusion: {:in=>[:FROM, :TO], :message=>"%{value} needs to be :FROM, :TO"}
+        validates :direction, presence: true, expression_inclusion: {:in=>[:FROM, :TO], :message=>"%{value} needs to be :FROM, :TO"}
 
         # @return [:MEMORY, :DISK, :RUNTIME, :CONFIG] RUNTIME - represents the in-memory data structures of ProxySQL used by the threads that are handling the requests. MEMORY - (sometimes also referred as main) represents the in-memory SQLite3 database. DISK - represents the on-disk SQLite3 database. CONFIG - is the classical config file. You can only LOAD FROM the config file.
         attribute :config_layer
-        validates :config_layer, presence: true, inclusion: {:in=>[:MEMORY, :DISK, :RUNTIME, :CONFIG], :message=>"%{value} needs to be :MEMORY, :DISK, :RUNTIME, :CONFIG"}
+        validates :config_layer, presence: true, expression_inclusion: {:in=>[:MEMORY, :DISK, :RUNTIME, :CONFIG], :message=>"%{value} needs to be :MEMORY, :DISK, :RUNTIME, :CONFIG"}
       end
     end
   end

data/lib/ansible/ruby/modules/generated/database/proxysql/proxysql_mysql_users.rb

@@ -35,18 +35,18 @@ module Ansible
 
         # @return [Boolean, nil] If I(backend) is set to C(True), this (username, password) pair is used for authenticating to the ProxySQL instance.
         attribute :backend
-        validates :backend, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :backend, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Boolean, nil] If I(frontend) is set to C(True), this (username, password) pair is used for authenticating to the mysqld servers against any hostgroup.
         attribute :frontend
-        validates :frontend, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :frontend, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Object, nil] The maximum number of connections ProxySQL will open to the backend for this user. If omitted the proxysql database default for I(max_connections) is 10000.
         attribute :max_connections
 
         # @return [:present, :absent, nil] When C(present) - adds the user, when C(absent) - removes the user.
         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/database/proxysql/proxysql_query_rules.rb

@@ -90,11 +90,11 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present) - adds the rule, when C(absent) - removes the rule.
         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 [Boolean, nil] By default we avoid deleting more than one schedule in a single batch, however if you need this behaviour and you're not concerned about the schedules deleted, you can set I(force_delete) to C(True).
         attribute :force_delete
-        validates :force_delete, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :force_delete, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/database/proxysql/proxysql_replication_hostgroups.rb

@@ -21,7 +21,7 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present) - adds the replication hostgroup, when C(absent) - removes the replication hostgroup.
         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/database/proxysql/proxysql_scheduler.rb

@@ -10,7 +10,7 @@ module Ansible
       class Proxysql_scheduler < Base
         # @return [Boolean, nil] A schedule with I(active) set to C(False) will be tracked in the database, but will be never loaded in the in-memory data structures.
         attribute :active
-        validates :active, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :active, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Integer, nil] How often (in millisecond) the job will be started. The minimum value for I(interval_ms) is 100 milliseconds.
         attribute :interval_ms
@@ -40,11 +40,11 @@ module Ansible
 
         # @return [:present, :absent, nil] When C(present) - adds the schedule, when C(absent) - removes the schedule.
         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 [Boolean, nil] By default we avoid deleting more than one schedule in a single batch, however if you need this behaviour and you're not concerned about the schedules deleted, you can set I(force_delete) to C(True).
         attribute :force_delete
-        validates :force_delete, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :force_delete, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/database/vertica/vertica_role.rb

@@ -17,7 +17,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Whether to create C(present), drop C(absent) or lock C(locked) a role.
         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 [String, nil] Name of the Vertica database.
         attribute :db

data/lib/ansible/ruby/modules/generated/database/vertica/vertica_schema.rb

@@ -28,7 +28,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Whether to create C(present), or drop C(absent) a schema.
         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 [String, nil] Name of the Vertica database.
         attribute :db

data/lib/ansible/ruby/modules/generated/database/vertica/vertica_user.rb

@@ -37,7 +37,7 @@ module Ansible
 
         # @return [:present, :absent, :locked, nil] Whether to create C(present), drop C(absent) or lock C(locked) a user.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent, :locked], :message=>"%{value} needs to be :present, :absent, :locked"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent, :locked], :message=>"%{value} needs to be :present, :absent, :locked"}, allow_nil: true
 
         # @return [String, nil] Name of the Vertica database.
         attribute :db

data/lib/ansible/ruby/modules/generated/files/acl.rb

@@ -14,15 +14,15 @@ module Ansible
 
         # @return [:absent, :present, :query, nil] defines whether the ACL should be present or not.  The C(query) state gets the current acl without changing it, for use in 'register' operations.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present, :query], :message=>"%{value} needs to be :absent, :present, :query"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present, :query], :message=>"%{value} needs to be :absent, :present, :query"}, allow_nil: true
 
         # @return [:yes, :no, nil] whether to follow symlinks on the path if a symlink is encountered.
         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
 
         # @return [:yes, :no, nil] if the target is a directory, setting this to yes will make it the default acl for entities created inside the directory. It causes an error if path is a file.
         attribute :default
-        validates :default, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :default, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] actual user or group that the ACL applies to when matching entity types user or group are selected.
         attribute :entity
@@ -30,7 +30,7 @@ module Ansible
 
         # @return [:group, :mask, :other, :user, nil] the entity type of the ACL to apply, see setfacl documentation for more info.
         attribute :etype
-        validates :etype, inclusion: {:in=>[:group, :mask, :other, :user], :message=>"%{value} needs to be :group, :mask, :other, :user"}, allow_nil: true
+        validates :etype, expression_inclusion: {:in=>[:group, :mask, :other, :user], :message=>"%{value} needs to be :group, :mask, :other, :user"}, allow_nil: true
 
         # @return [String, nil] Permissions to apply/remove can be any combination of r, w and  x (read, write and execute respectively)
         attribute :permissions
@@ -42,11 +42,11 @@ module Ansible
 
         # @return [:yes, :no, nil] Recursively sets the specified ACL (added in Ansible 2.0). Incompatible with C(state=query).
         attribute :recursive
-        validates :recursive, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :recursive, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:default, :mask, :no_mask, nil] Select if and when to recalculate the effective right masks of the files, see setfacl documentation for more info. Incompatible with C(state=query).
         attribute :recalculate_mask
-        validates :recalculate_mask, inclusion: {:in=>[:default, :mask, :no_mask], :message=>"%{value} needs to be :default, :mask, :no_mask"}, allow_nil: true
+        validates :recalculate_mask, expression_inclusion: {:in=>[:default, :mask, :no_mask], :message=>"%{value} needs to be :default, :mask, :no_mask"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/files/archive.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:bz2, :gz, :tar, :xz, :zip, nil] The type of compression to use.,Support for xz was added in version 2.5.
         attribute :format
-        validates :format, inclusion: {:in=>[:bz2, :gz, :tar, :xz, :zip], :message=>"%{value} needs to be :bz2, :gz, :tar, :xz, :zip"}, allow_nil: true
+        validates :format, expression_inclusion: {:in=>[:bz2, :gz, :tar, :xz, :zip], :message=>"%{value} needs to be :bz2, :gz, :tar, :xz, :zip"}, allow_nil: true
 
         # @return [String, nil] The file name of the destination archive. This is required when C(path) refers to multiple files by either specifying a glob, a directory or multiple paths in a list.
         attribute :dest
@@ -26,7 +26,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Remove any added source files and trees after adding to archive.
         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
       end
     end
   end

data/lib/ansible/ruby/modules/generated/files/assemble.rb

@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Create a backup file (if C(yes)), 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 [String, nil] A delimiter to separate the file contents.
         attribute :delimiter
@@ -26,14 +26,14 @@ module Ansible
 
         # @return [:yes, :no, nil] If False, it will search for src at originating/master machine, if True it will go to the remote/target machine for the src. Default is True.
         attribute :remote_src
-        validates :remote_src, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :remote_src, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Object, nil] Assemble files only if C(regex) matches the filename. If not set, all files are assembled. All "\\" (backslash) must be escaped as "\\\\" to comply yaml syntax. Uses Python regular expressions; see U(http://docs.python.org/2/library/re.html).
         attribute :regexp
 
         # @return [:yes, :no, nil] A boolean that controls if files that start with a '.' will be included or not.
         attribute :ignore_hidden
-        validates :ignore_hidden, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :ignore_hidden, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] The validation command to run before copying into place.  The path to the file to validate is passed in via '%s' which must be present as in the sshd example below. The command is passed securely so shell features like expansion and pipes won't work.
         attribute :validate

data/lib/ansible/ruby/modules/generated/files/blockinfile.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:absent, :present, nil] Whether the block should be there 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 [String, nil] The marker line template. "{mark}" will be replaced with the values in marker_begin (default="BEGIN") and marker_end (default="END").
         attribute :marker
@@ -26,19 +26,19 @@ module Ansible
 
         # @return [:EOF, :"*regex*", nil] If specified, the block will be inserted after the last match of specified regular expression. A special value is available; C(EOF) for inserting the block at the end of the file.  If specified regular expression has no matches, C(EOF) will be used instead.
         attribute :insertafter
-        validates :insertafter, inclusion: {:in=>[:EOF, :"*regex*"], :message=>"%{value} needs to be :EOF, :\"*regex*\""}, allow_nil: true
+        validates :insertafter, expression_inclusion: {:in=>[:EOF, :"*regex*"], :message=>"%{value} needs to be :EOF, :\"*regex*\""}, allow_nil: true
 
         # @return [:BOF, :"*regex*", nil] If specified, the block will be inserted before the last match of specified regular expression. A special value is available; C(BOF) for inserting the block at the beginning of the file.  If specified regular expression has no matches, the block will be inserted at the end of the file.
         attribute :insertbefore
-        validates :insertbefore, inclusion: {:in=>[:BOF, :"*regex*"], :message=>"%{value} needs to be :BOF, :\"*regex*\""}, allow_nil: true
+        validates :insertbefore, expression_inclusion: {:in=>[:BOF, :"*regex*"], :message=>"%{value} needs to be :BOF, :\"*regex*\""}, allow_nil: true
 
         # @return [:yes, :no, nil] Create a new file if it doesn't exist.
         attribute :create
-        validates :create, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :create, 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
 
         # @return [String, nil] This will be inserted at {mark} in the opening ansible block marker.
         attribute :marker_begin

data/lib/ansible/ruby/modules/generated/files/copy.rb

@@ -23,11 +23,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 [:yes, :no, nil] the default is C(yes), which will replace the remote file when contents are different than the source. If C(no), the file will only be transferred if the destination does not exist.
         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 [Integer, Array<String>, String, nil] Mode the file or directory should be. For those used to I(/usr/bin/chmod) remember that modes are actually octal numbers. You must either add a leading zero so that Ansible's YAML parser knows it is an octal number (like C(0644) or C(01777)) or quote it (like C('644') or C('1777')) so Ansible receives a string and can do its own conversion from string into number.  Giving Ansible a number without following one of these rules will end up with a decimal number which will have unexpected results.  As of version 1.8, the mode may be specified as a symbolic mode (for example, C(u+rwx) or C(u=rw,g=r,o=r)).  As of version 2.3, the mode may also be the special string C(preserve).  C(preserve) means that the file will be given the same permissions as the source file.
         attribute :mode
@@ -38,15 +38,15 @@ module Ansible
 
         # @return [:yes, :no, nil] If C(no), it will search for I(src) at originating/master machine.,If C(yes) it will go to the remote/target machine for the I(src). Default is C(no).,Currently I(remote_src) does not support recursive copying.,I(remote_src) only works with C(mode=preserve) as of version 2.6.
         attribute :remote_src
-        validates :remote_src, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :remote_src, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] This flag indicates that filesystem links in the destination, if they exist, should be followed.
         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
 
         # @return [:yes, :no, nil] This flag indicates that filesystem links in the source tree, if they exist, should be followed.
         attribute :local_follow
-        validates :local_follow, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :local_follow, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Object, nil] SHA1 checksum of the file being transferred. Used to validate that the copy of the file was successful.,If this is not provided, ansible will use the local calculated checksum of the src file.
         attribute :checksum

data/lib/ansible/ruby/modules/generated/files/fetch.rb

@@ -19,15 +19,15 @@ module Ansible
 
         # @return [:yes, :no, nil] When set to 'yes', the task will fail if the remote file cannot be read for any reason.  Prior to Ansible-2.5, setting this would only fail if the source file was missing.,The default was changed to "yes" in Ansible-2.5.
         attribute :fail_on_missing
-        validates :fail_on_missing, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :fail_on_missing, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Verify that the source and destination checksums match after the files are fetched.
         attribute :validate_checksum
-        validates :validate_checksum, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :validate_checksum, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Allows you to override the default behavior of appending hostname/path/to/file to the destination.  If dest ends with '/', it will use the basename of the source file, similar to the copy module. Obviously this is only handy if the filenames are unique.
         attribute :flat
-        validates :flat, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :flat, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/files/file.rb

@@ -15,7 +15,7 @@ module Ansible
 
         # @return [:absent, :directory, :file, :hard, :link, :touch, nil] If C(directory), all intermediate subdirectories will be created if they do not exist. Since Ansible 1.7 they will be created with the supplied permissions. If C(file), the file will NOT be created if it does not exist; see the C(touch) value or the M(copy) or M(template) module if you want that behavior.  If C(link), the symbolic link will be created or changed. Use C(hard) for hardlinks. If C(absent), directories will be recursively deleted, and files or symlinks will be unlinked. Note that C(absent) will not cause C(file) to fail if the C(path) does not exist as the state did not change. If C(touch) (new in 1.4), an empty file will be created if the C(path) does not exist, while an existing file or directory will receive updated file access and modification times (similar to the way `touch` works from the command line).
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :directory, :file, :hard, :link, :touch], :message=>"%{value} needs to be :absent, :directory, :file, :hard, :link, :touch"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :directory, :file, :hard, :link, :touch], :message=>"%{value} needs to be :absent, :directory, :file, :hard, :link, :touch"}, allow_nil: true
 
         # @return [String, nil] path of the file to link to (applies only to C(state=link) and C(state=hard)). Will accept absolute, relative and nonexisting paths. Relative paths are relative to the file being created (C(path)) which is how the UNIX command C(ln -s SRC DEST) treats relative paths.
         attribute :src
@@ -23,15 +23,15 @@ module Ansible
 
         # @return [:yes, :no, nil] recursively set the specified file attributes (applies only to directories)
         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] force the creation of the symlinks in two cases: the source file does not exist (but will appear later); the destination exists and is a file (so, we need to unlink the "path" file and create symlink to the "src" file in place of it).
         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 flag indicates that filesystem links, if they exist, should be followed.,Previous to Ansible 2.5, this was C(no) by default.
         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
 
         # @return [String, nil] This parameter indicates the time the file's modification time should be set to,Should be C(preserve) when no modification is required, C(YYYYMMDDHHMM.SS) when using default time format, or C(now),Default is None meaning that C(preserve) is the default for C(state=[file,directory,link,hard]) and C(now) is default for C(state=touch)
         attribute :modification_time

data/lib/ansible/ruby/modules/generated/files/find.rb

@@ -30,11 +30,11 @@ module Ansible
 
         # @return [:any, :directory, :file, :link, nil] Type of file to select.,The 'link' and 'any' choices were added in version 2.3.
         attribute :file_type
-        validates :file_type, inclusion: {:in=>[:any, :directory, :file, :link], :message=>"%{value} needs to be :any, :directory, :file, :link"}, allow_nil: true
+        validates :file_type, expression_inclusion: {:in=>[:any, :directory, :file, :link], :message=>"%{value} needs to be :any, :directory, :file, :link"}, allow_nil: true
 
         # @return [:yes, :no, nil] If target is a directory, recursively descend into the directory looking for files.
         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 [String, nil] Select files whose size is equal to or greater than the specified size. Use a negative size to find files equal to or less than the specified size. Unqualified values are in bytes but b, k, m, g, and t can be appended to specify bytes, kilobytes, megabytes, gigabytes, and terabytes, respectively. Size is not evaluated for directories.
         attribute :size
@@ -42,23 +42,23 @@ module Ansible
 
         # @return [:atime, :ctime, :mtime, nil] Choose the file property against which we compare age.
         attribute :age_stamp
-        validates :age_stamp, inclusion: {:in=>[:atime, :ctime, :mtime], :message=>"%{value} needs to be :atime, :ctime, :mtime"}, allow_nil: true
+        validates :age_stamp, expression_inclusion: {:in=>[:atime, :ctime, :mtime], :message=>"%{value} needs to be :atime, :ctime, :mtime"}, allow_nil: true
 
         # @return [:yes, :no, nil] Set this to true to include hidden files, otherwise they'll be ignored.
         attribute :hidden
-        validates :hidden, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :hidden, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Set this to true to follow symlinks in path for systems with python 2.6+.
         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
 
         # @return [:yes, :no, nil] Set this to true to retrieve a file's sha1 checksum.
         attribute :get_checksum
-        validates :get_checksum, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :get_checksum, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] If false, the patterns are file globs (shell). If true, they are python regexes.
         attribute :use_regex
-        validates :use_regex, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :use_regex, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Object, nil] Set the maximum number of levels to decend into. Setting recurse to false will override this value, which is effectively depth 1. Default is unlimited depth.
         attribute :depth

data/lib/ansible/ruby/modules/generated/files/ini_file.rb

@@ -28,22 +28,22 @@ 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 [Object, nil] All arguments accepted by the M(file) module also work here
         attribute :others
 
         # @return [:absent, :present, nil] If set to C(absent) the option or section will be removed if present instead of created.
         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] Do not insert spaces before and after '=' symbol
         attribute :no_extra_spaces
-        validates :no_extra_spaces, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :no_extra_spaces, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] If set to 'no', the module will fail if the file does not already exist. By default it will create the file if it is missing.
         attribute :create
-        validates :create, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :create, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Symbol, nil] allow option without value and without '=' symbol
         attribute :allow_no_value

data/lib/ansible/ruby/modules/generated/files/iso_extract.rb

@@ -24,7 +24,7 @@ module Ansible
 
         # @return [:yes, :no, nil] If C(yes), which will replace the remote file when contents are different than the source.,If C(no), the file will only be extracted and copied if the destination does not already exist.
         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] The path to the C(7z) executable to use for extracting files from the ISO.
         attribute :executable

data/lib/ansible/ruby/modules/generated/files/lineinfile.rb

@@ -19,7 +19,7 @@ module Ansible
 
         # @return [:absent, :present, nil] Whether the line should be there 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 [String, nil] Required for C(state=present). The line to insert/replace into the file. If C(backrefs) is set, may contain backreferences that will get expanded with the C(regexp) capture groups if the regexp matches.
         attribute :line
@@ -27,27 +27,27 @@ module Ansible
 
         # @return [:yes, :no, nil] Used with C(state=present). If set, C(line) can contain backreferences (both positional and named) that will get populated if the C(regexp) matches. This flag changes the operation of the module slightly; C(insertbefore) and C(insertafter) will be ignored, and if the C(regexp) doesn't match anywhere in the file, the file will be left unchanged. If the C(regexp) does match, the last matching line will be replaced by the expanded line parameter.
         attribute :backrefs
-        validates :backrefs, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :backrefs, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:EOF, :"*regex*", nil] Used with C(state=present). If specified, the line will be inserted after the last match of specified regular expression. If the first match is required, use(firstmatch=yes). A special value is available; C(EOF) for inserting the line at the end of the file. If specified regular expression has no matches, EOF will be used instead. If regular expressions are passed to both C(regexp) and C(insertafter), C(insertafter) is only honored if no match for C(regexp) is found. May not be used with C(backrefs).
         attribute :insertafter
-        validates :insertafter, inclusion: {:in=>[:EOF, :"*regex*"], :message=>"%{value} needs to be :EOF, :\"*regex*\""}, allow_nil: true
+        validates :insertafter, expression_inclusion: {:in=>[:EOF, :"*regex*"], :message=>"%{value} needs to be :EOF, :\"*regex*\""}, allow_nil: true
 
         # @return [:BOF, :"*regex*", nil] Used with C(state=present). If specified, the line will be inserted before the last match of specified regular expression. If the first match is required, use(firstmatch=yes). A value is available; C(BOF) for inserting the line at the beginning of the file. If specified regular expression has no matches, the line will be inserted at the end of the file. If regular expressions are passed to both C(regexp) and C(insertbefore), C(insertbefore) is only honored if no match for C(regexp) is found. May not be used with C(backrefs).
         attribute :insertbefore
-        validates :insertbefore, inclusion: {:in=>[:BOF, :"*regex*"], :message=>"%{value} needs to be :BOF, :\"*regex*\""}, allow_nil: true
+        validates :insertbefore, expression_inclusion: {:in=>[:BOF, :"*regex*"], :message=>"%{value} needs to be :BOF, :\"*regex*\""}, allow_nil: true
 
         # @return [:yes, :no, nil] Used with C(state=present). If specified, the file will be created if it does not already exist. By default it will fail if the file is missing.
         attribute :create
-        validates :create, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :create, 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
 
         # @return [:yes, :no, nil] Used with C(insertafter) or C(insertbefore). If set, C(insertafter) and C(inserbefore) find a first line has regular expression matches.
         attribute :firstmatch
-        validates :firstmatch, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :firstmatch, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Object, nil] All arguments accepted by the M(file) module also work here.
         attribute :others