ansible-ruby 1.0.22 → 1.0.23

data/lib/ansible/ruby/modules/generated/crypto/openssl_dhparam.rb

@@ -10,7 +10,7 @@ module Ansible
       class Openssl_dhparam < Base
         # @return [:present, :absent, nil] Whether the parameters should exist or not, taking action if the state is different from what is stated.
         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 [Integer, nil] Size (in bits) of the generated DH-params
         attribute :size

data/lib/ansible/ruby/modules/generated/crypto/openssl_pkcs12.rb

@@ -10,7 +10,7 @@ module Ansible
       class Openssl_pkcs12 < Base
         # @return [:parse, :export, nil] C(export) or C(parse) a PKCS#12.
         attribute :action
-        validates :action, inclusion: {:in=>[:parse, :export], :message=>"%{value} needs to be :parse, :export"}, allow_nil: true
+        validates :action, expression_inclusion: {:in=>[:parse, :export], :message=>"%{value} needs to be :parse, :export"}, allow_nil: true
 
         # @return [String, nil] List of CA certificate to include.
         attribute :ca_certificates
@@ -52,7 +52,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Whether the file should exist or not. All parameters except C(path) are ignored when state is C(absent).
         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] PKCS#12 file path to parse.
         attribute :src

data/lib/ansible/ruby/modules/generated/crypto/openssl_privatekey.rb

@@ -10,7 +10,7 @@ module Ansible
       class Openssl_privatekey < Base
         # @return [:present, :absent, nil] Whether the private key should exist or not, taking action if the state is different from what is stated.
         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 [Integer, nil] Size (in bits) of the TLS/SSL key to generate
         attribute :size
@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:RSA, :DSA, nil] The algorithm used to generate the TLS/SSL private key
         attribute :type
-        validates :type, inclusion: {:in=>[:RSA, :DSA], :message=>"%{value} needs to be :RSA, :DSA"}, allow_nil: true
+        validates :type, expression_inclusion: {:in=>[:RSA, :DSA], :message=>"%{value} needs to be :RSA, :DSA"}, allow_nil: true
 
         # @return [Symbol, nil] Should the key be regenerated even if it already exists
         attribute :force

data/lib/ansible/ruby/modules/generated/crypto/openssl_publickey.rb

@@ -10,7 +10,7 @@ module Ansible
       class Openssl_publickey < Base
         # @return [:present, :absent, nil] Whether the public key should exist or not, taking action if the state is different from what is stated.
         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] Should the key be regenerated even it it already exists
         attribute :force
@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:PEM, :OpenSSH, nil] The format of the public key.
         attribute :format
-        validates :format, inclusion: {:in=>[:PEM, :OpenSSH], :message=>"%{value} needs to be :PEM, :OpenSSH"}, allow_nil: true
+        validates :format, expression_inclusion: {:in=>[:PEM, :OpenSSH], :message=>"%{value} needs to be :PEM, :OpenSSH"}, allow_nil: true
 
         # @return [String] Name of the file in which the generated TLS/SSL public key will be written.
         attribute :path

data/lib/ansible/ruby/modules/generated/database/influxdb/influxdb_database.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Determines if the database should be created or destroyed.
         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/influxdb/influxdb_user.rb

@@ -22,7 +22,7 @@ module Ansible
 
         # @return [:present, :absent, nil] State of 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/misc/elasticsearch_plugin.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Desired state of a plugin.
         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 [Object, nil] Optionally set the source location to retrieve the plugin from. This can be a file:// URL to install from a local file, or a remote URL. If this is not set, the plugin location is just based on the name.,The name parameter must match the descriptor in the plugin ZIP specified.,Is only used if the state would change, which is solely checked based on the name parameter. If, for example, the plugin is already installed, changing this has no effect.,For ES 1.x use url.
         attribute :src
@@ -28,7 +28,7 @@ module Ansible
 
         # @return [Boolean, nil] Force batch mode when installing plugins. This is only necessary if a plugin requires additional permissions and console detection fails.
         attribute :force
-        validates :force, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :force, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Object, nil] Location of the plugin binary. If this file is not found, the default plugin binaries will be used.,The default changed in Ansible 2.4 to None.
         attribute :plugin_bin

data/lib/ansible/ruby/modules/generated/database/misc/kibana_plugin.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Desired state of a plugin.
         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 [Object, nil] Set exact URL to download the plugin from. For local file, prefix its absolute path with file://
         attribute :url
@@ -37,7 +37,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Delete and re-install the plugin. Can be useful for plugins update
         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/database/misc/redis.rb

@@ -10,7 +10,7 @@ module Ansible
       class Redis < Base
         # @return [:config, :flush, :slave] The selected redis command,C(config) (new in 1.6), ensures a configuration setting on an instance.,C(flush) flushes all the instance or a specified db.,C(slave) sets a redis instance in slave or master mode.
         attribute :command
-        validates :command, presence: true, inclusion: {:in=>[:config, :flush, :slave], :message=>"%{value} needs to be :config, :flush, :slave"}
+        validates :command, presence: true, expression_inclusion: {:in=>[:config, :flush, :slave], :message=>"%{value} needs to be :config, :flush, :slave"}
 
         # @return [Object, nil] The password used to authenticate with (usually not used)
         attribute :login_password
@@ -33,7 +33,7 @@ module Ansible
 
         # @return [:master, :slave, nil] the mode of the redis instance [slave command]
         attribute :slave_mode
-        validates :slave_mode, inclusion: {:in=>[:master, :slave], :message=>"%{value} needs to be :master, :slave"}, allow_nil: true
+        validates :slave_mode, expression_inclusion: {:in=>[:master, :slave], :message=>"%{value} needs to be :master, :slave"}, allow_nil: true
 
         # @return [Integer, nil] The database to flush (used in db mode) [flush command]
         attribute :db
@@ -41,7 +41,7 @@ module Ansible
 
         # @return [:all, :db, nil] Type of flush (all the dbs in a redis instance or a specific one) [flush command]
         attribute :flush_mode
-        validates :flush_mode, inclusion: {:in=>[:all, :db], :message=>"%{value} needs to be :all, :db"}, allow_nil: true
+        validates :flush_mode, expression_inclusion: {:in=>[:all, :db], :message=>"%{value} needs to be :all, :db"}, allow_nil: true
 
         # @return [String, nil] A redis config key.
         attribute :name

data/lib/ansible/ruby/modules/generated/database/misc/riak.rb

@@ -10,7 +10,7 @@ module Ansible
       class Riak < Base
         # @return [:ping, :kv_test, :join, :plan, :commit, nil] The command you would like to perform against the cluster.
         attribute :command
-        validates :command, inclusion: {:in=>[:ping, :kv_test, :join, :plan, :commit], :message=>"%{value} needs to be :ping, :kv_test, :join, :plan, :commit"}, allow_nil: true
+        validates :command, expression_inclusion: {:in=>[:ping, :kv_test, :join, :plan, :commit], :message=>"%{value} needs to be :ping, :kv_test, :join, :plan, :commit"}, allow_nil: true
 
         # @return [String, nil] The path to the riak configuration directory
         attribute :config_dir
@@ -26,18 +26,18 @@ module Ansible
 
         # @return [Boolean, nil] Number of seconds to wait for handoffs to complete.
         attribute :wait_for_handoffs
-        validates :wait_for_handoffs, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :wait_for_handoffs, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Object, nil] Number of seconds to wait for all nodes to agree on the ring.
         attribute :wait_for_ring
 
         # @return [:kv, nil] Waits for a riak service to come online before continuing.
         attribute :wait_for_service
-        validates :wait_for_service, inclusion: {:in=>[:kv], :message=>"%{value} needs to be :kv"}, allow_nil: true
+        validates :wait_for_service, expression_inclusion: {:in=>[:kv], :message=>"%{value} needs to be :kv"}, allow_nil: true
 
         # @return [:yes, :no, nil] If C(no), SSL certificates will not be validated. This should only be used on personally controlled sites using self-signed certificates.
         attribute :validate_certs
-        validates :validate_certs, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :validate_certs, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/database/mongodb/mongodb_parameter.rb

@@ -34,7 +34,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Whether to use an SSL connection when connecting to the database
         attribute :ssl
-        validates :ssl, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :ssl, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String] MongoDB administrative parameter to modify
         attribute :param

data/lib/ansible/ruby/modules/generated/database/mongodb/mongodb_user.rb

@@ -45,11 +45,11 @@ module Ansible
 
         # @return [Boolean, nil] Whether to use an SSL connection when connecting to the database
         attribute :ssl
-        validates :ssl, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :ssl, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [:CERT_REQUIRED, :CERT_OPTIONAL, :CERT_NONE, nil] Specifies whether a certificate is required from the other side of the connection, and whether it will be validated if provided.
         attribute :ssl_cert_reqs
-        validates :ssl_cert_reqs, inclusion: {:in=>[:CERT_REQUIRED, :CERT_OPTIONAL, :CERT_NONE], :message=>"%{value} needs to be :CERT_REQUIRED, :CERT_OPTIONAL, :CERT_NONE"}, allow_nil: true
+        validates :ssl_cert_reqs, expression_inclusion: {:in=>[:CERT_REQUIRED, :CERT_OPTIONAL, :CERT_NONE], :message=>"%{value} needs to be :CERT_REQUIRED, :CERT_OPTIONAL, :CERT_NONE"}, allow_nil: true
 
         # @return [String, nil] The database user roles valid values could either be one or more of the following strings: 'read', 'readWrite', 'dbAdmin', 'userAdmin', 'clusterAdmin', 'readAnyDatabase', 'readWriteAnyDatabase', 'userAdminAnyDatabase', 'dbAdminAnyDatabase'\r\n,Or the following dictionary '{ db: DATABASE_NAME, role: ROLE_NAME }'.,This param requires pymongo 2.5+. If it is a string, mongodb 2.4+ is also required. If it is a dictionary, mongo 2.6+  is required.
         attribute :roles
@@ -57,11 +57,11 @@ module Ansible
 
         # @return [:present, :absent, nil] The database user state
         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 [: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
       end
     end
   end

data/lib/ansible/ruby/modules/generated/database/mssql/mssql_db.rb

@@ -27,7 +27,7 @@ module Ansible
 
         # @return [:present, :absent, :import, nil] The database state
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent, :import], :message=>"%{value} needs to be :present, :absent, :import"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent, :import], :message=>"%{value} needs to be :present, :absent, :import"}, allow_nil: true
 
         # @return [String, nil] Location, on the remote host, of the dump file to read from or write to. Uncompressed SQL files (C(.sql)) files are supported.
         attribute :target
@@ -35,7 +35,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Automatically commit the change only if the import succeed. Sometimes it is necessary to use autocommit=true, since some content can't be changed within a transaction.
         attribute :autocommit
-        validates :autocommit, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :autocommit, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/database/mysql/mysql_db.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:present, :absent, :dump, :import, nil] The database state
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent, :dump, :import], :message=>"%{value} needs to be :present, :absent, :dump, :import"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent, :dump, :import], :message=>"%{value} needs to be :present, :absent, :dump, :import"}, allow_nil: true
 
         # @return [Object, nil] Collation mode (sorting). This only applies to new table/databases and does not update existing ones, this is a limitation of MySQL.
         attribute :collation
@@ -28,11 +28,11 @@ module Ansible
 
         # @return [:yes, :no, nil] Execute the dump in a single transaction
         attribute :single_transaction
-        validates :single_transaction, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :single_transaction, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Option used for dumping large tables
         attribute :quick
-        validates :quick, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :quick, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Object, nil] A list of table names that will be ignored in the dump of the form database_name.table_name
         attribute :ignore_tables

data/lib/ansible/ruby/modules/generated/database/mysql/mysql_replication.rb

@@ -10,7 +10,7 @@ module Ansible
       class Mysql_replication < Base
         # @return [:getslave, :getmaster, :changemaster, :stopslave, :startslave, :resetslave, :resetslaveall, nil] module operating mode. Could be getslave (SHOW SLAVE STATUS), getmaster (SHOW MASTER STATUS), changemaster (CHANGE MASTER TO), startslave (START SLAVE), stopslave (STOP SLAVE), resetslave (RESET SLAVE), resetslaveall (RESET SLAVE ALL)
         attribute :mode
-        validates :mode, inclusion: {:in=>[:getslave, :getmaster, :changemaster, :stopslave, :startslave, :resetslave, :resetslaveall], :message=>"%{value} needs to be :getslave, :getmaster, :changemaster, :stopslave, :startslave, :resetslave, :resetslaveall"}, allow_nil: true
+        validates :mode, expression_inclusion: {:in=>[:getslave, :getmaster, :changemaster, :stopslave, :startslave, :resetslave, :resetslaveall], :message=>"%{value} needs to be :getslave, :getmaster, :changemaster, :stopslave, :startslave, :resetslave, :resetslaveall"}, allow_nil: true
 
         # @return [String, nil] same as mysql variable
         attribute :master_host
@@ -44,7 +44,7 @@ module Ansible
 
         # @return [0, 1, nil] same as mysql variable
         attribute :master_ssl
-        validates :master_ssl, inclusion: {:in=>[0, 1], :message=>"%{value} needs to be 0, 1"}, allow_nil: true
+        validates :master_ssl, expression_inclusion: {:in=>[0, 1], :message=>"%{value} needs to be 0, 1"}, allow_nil: true
 
         # @return [Object, nil] same as mysql variable
         attribute :master_ssl_ca

data/lib/ansible/ruby/modules/generated/database/mysql/mysql_user.rb

@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Indicate that the 'password' field is a `mysql_native_password` hash
         attribute :encrypted
-        validates :encrypted, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :encrypted, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] the 'host' part of the MySQL username
         attribute :host
@@ -26,7 +26,7 @@ module Ansible
 
         # @return [:yes, :no, nil] override the host option, making ansible apply changes to all hostnames for a given user.  This option cannot be used when creating users
         attribute :host_all
-        validates :host_all, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :host_all, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Array<String>, String, nil] MySQL privileges string in the format: C(db.table:priv1,priv2).,Multiple privileges can be specified by separating each one using a forward slash: C(db.table:priv/db.table:priv).,The format is based on MySQL C(GRANT) statement.,Database and table names can be quoted, MySQL-style.,If column privileges are used, the C(priv1,priv2) part must be exactly as returned by a C(SHOW GRANT) statement. If not followed, the module will always report changes. It includes grouping columns by permission (C(SELECT(col1,col2)) instead of C(SELECT(col1),SELECT(col2))).
         attribute :priv
@@ -34,23 +34,23 @@ module Ansible
 
         # @return [:yes, :no, nil] Append the privileges defined by priv to the existing ones for this user instead of overwriting existing ones.
         attribute :append_privs
-        validates :append_privs, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :append_privs, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Whether binary logging should be enabled or disabled for the connection.
         attribute :sql_log_bin
-        validates :sql_log_bin, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :sql_log_bin, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:present, :absent, nil] Whether the user should exist.  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
 
         # @return [:yes, :no, nil] Check if mysql allows login as root/nopassword before trying supplied credentials.
         attribute :check_implicit_admin
-        validates :check_implicit_admin, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :check_implicit_admin, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @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
       end
     end
   end

data/lib/ansible/ruby/modules/generated/database/postgresql/postgresql_db.rb

@@ -33,7 +33,7 @@ module Ansible
 
         # @return [:present, :absent, :dump, :restore, nil] The database state. present implies that the database should be created if necessary.\r\nabsent implies that the database should be removed if present.\r\ndump requires a target definition to which the database will be backed up.\r\n(Added in 2.4) restore also requires a target definition from which the database will be restored.\r\n(Added in 2.4) The format of the backup will be detected based on the target name.\r\nSupported compression formats for dump and restore are: .bz2, .gz, and .xz\r\nSupported formats for dump and restore are: .sql and .tar\r\n
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent, :dump, :restore], :message=>"%{value} needs to be :present, :absent, :dump, :restore"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent, :dump, :restore], :message=>"%{value} needs to be :present, :absent, :dump, :restore"}, allow_nil: true
 
         # @return [String, nil] File to back up or restore from. Used when state is "dump" or "restore"
         attribute :target

data/lib/ansible/ruby/modules/generated/database/postgresql/postgresql_ext.rb

@@ -32,7 +32,7 @@ module Ansible
 
         # @return [:present, :absent, nil] The database extension state
         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/postgresql/postgresql_lang.rb

@@ -17,7 +17,7 @@ module Ansible
 
         # @return [:yes, :no, nil] make this language trusted for the selected db
         attribute :trust
-        validates :trust, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :trust, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] name of database where the language will be added, removed or changed
         attribute :db
@@ -25,15 +25,15 @@ module Ansible
 
         # @return [:yes, :no, nil] marks the language as trusted, even if it's marked as untrusted in pg_pltemplate.,use with care!
         attribute :force_trust
-        validates :force_trust, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :force_trust, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] if C(yes), fail when removing a language. Otherwise just log and continue,in some cases, it is not possible to remove a language (used by the db-system). When         dependencies block the removal, consider using C(cascade).
         attribute :fail_on_drop
-        validates :fail_on_drop, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :fail_on_drop, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] when dropping a language, also delete object that depend on this language.,only used when C(state=absent).
         attribute :cascade
-        validates :cascade, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :cascade, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Integer, nil] Database port to connect to.
         attribute :port
@@ -52,7 +52,7 @@ module Ansible
 
         # @return [:present, :absent, nil] The state of the language for the selected database
         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/postgresql/postgresql_privs.rb

@@ -15,7 +15,7 @@ module Ansible
 
         # @return [:present, :absent, nil] If C(present), the specified privileges are granted, if C(absent) they are revoked.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent], :message=>"%{value} needs to be :present, :absent"}, allow_nil: true
 
         # @return [Array<String>, String, nil] Comma separated list of privileges to grant/revoke.,Alias: I(priv)
         attribute :privs
@@ -23,7 +23,7 @@ module Ansible
 
         # @return [:table, :sequence, :function, :database, :schema, :language, :tablespace, :group, :default_privs, nil] Type of database object to set privileges on.,The `default_prives` choice is available starting at version 2.7.
         attribute :type
-        validates :type, inclusion: {:in=>[:table, :sequence, :function, :database, :schema, :language, :tablespace, :group, :default_privs], :message=>"%{value} needs to be :table, :sequence, :function, :database, :schema, :language, :tablespace, :group, :default_privs"}, allow_nil: true
+        validates :type, expression_inclusion: {:in=>[:table, :sequence, :function, :database, :schema, :language, :tablespace, :group, :default_privs], :message=>"%{value} needs to be :table, :sequence, :function, :database, :schema, :language, :tablespace, :group, :default_privs"}, allow_nil: true
 
         # @return [Array<String>, String, nil] Comma separated list of database objects to set privileges on.,If I(type) is C(table) or C(sequence), the special value C(ALL_IN_SCHEMA) can be provided instead to specify all database objects of type I(type) in the schema specified via I(schema). (This also works with PostgreSQL < 9.0.),If I(type) is C(database), this parameter can be omitted, in which case privileges are set for the database specified via I(database).,If I(type) is I(function), colons (":") in object names will be replaced with commas (needed to specify function signatures, see examples),Alias: I(obj)
         attribute :objs
@@ -60,7 +60,7 @@ module Ansible
 
         # @return [:disable, :allow, :prefer, :require, :"verify-ca", :"verify-full", nil] Determines whether or with what priority a secure SSL TCP/IP connection will be negotiated with the server.,See https://www.postgresql.org/docs/current/static/libpq-ssl.html for more information on the modes.,Default of C(prefer) matches libpq default.
         attribute :ssl_mode
-        validates :ssl_mode, inclusion: {:in=>[:disable, :allow, :prefer, :require, :"verify-ca", :"verify-full"], :message=>"%{value} needs to be :disable, :allow, :prefer, :require, :\"verify-ca\", :\"verify-full\""}, allow_nil: true
+        validates :ssl_mode, expression_inclusion: {:in=>[:disable, :allow, :prefer, :require, :"verify-ca", :"verify-full"], :message=>"%{value} needs to be :disable, :allow, :prefer, :require, :\"verify-ca\", :\"verify-full\""}, allow_nil: true
 
         # @return [Object, nil] Specifies the name of a file containing SSL certificate authority (CA) certificate(s). If the file exists, the server's certificate will be verified to be signed by one of these authorities.
         attribute :ssl_rootcert

data/lib/ansible/ruby/modules/generated/database/postgresql/postgresql_schema.rb

@@ -39,7 +39,7 @@ module Ansible
 
         # @return [:present, :absent, nil] The schema state.
         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/postgresql/postgresql_user.rb

@@ -24,7 +24,7 @@ module Ansible
 
         # @return [:yes, :no, nil] If C(yes), fail when user can't be removed. Otherwise just log and continue.
         attribute :fail_on_user
-        validates :fail_on_user, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :fail_on_user, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Integer, nil] Database port to connect to.
         attribute :port
@@ -50,15 +50,15 @@ module Ansible
 
         # @return [:"[NO]SUPERUSER", :"[NO]CREATEROLE", :"[NO]CREATEDB", :"[NO]INHERIT", :"[NO]LOGIN", :"[NO]REPLICATION", :"[NO]BYPASSRLS", nil] PostgreSQL role attributes string in the format: CREATEDB,CREATEROLE,SUPERUSER.,Note that '[NO]CREATEUSER' is deprecated.
         attribute :role_attr_flags
-        validates :role_attr_flags, inclusion: {:in=>[:"[NO]SUPERUSER", :"[NO]CREATEROLE", :"[NO]CREATEDB", :"[NO]INHERIT", :"[NO]LOGIN", :"[NO]REPLICATION", :"[NO]BYPASSRLS"], :message=>"%{value} needs to be :\"[NO]SUPERUSER\", :\"[NO]CREATEROLE\", :\"[NO]CREATEDB\", :\"[NO]INHERIT\", :\"[NO]LOGIN\", :\"[NO]REPLICATION\", :\"[NO]BYPASSRLS\""}, allow_nil: true
+        validates :role_attr_flags, expression_inclusion: {:in=>[:"[NO]SUPERUSER", :"[NO]CREATEROLE", :"[NO]CREATEDB", :"[NO]INHERIT", :"[NO]LOGIN", :"[NO]REPLICATION", :"[NO]BYPASSRLS"], :message=>"%{value} needs to be :\"[NO]SUPERUSER\", :\"[NO]CREATEROLE\", :\"[NO]CREATEDB\", :\"[NO]INHERIT\", :\"[NO]LOGIN\", :\"[NO]REPLICATION\", :\"[NO]BYPASSRLS\""}, allow_nil: true
 
         # @return [:present, :absent, nil] The user (role) state.
         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] Whether the password is stored hashed in the database. Passwords can be passed already hashed or unhashed, and postgresql ensures the stored password is hashed when C(encrypted) is set.,Note: Postgresql 10 and newer doesn't support unhashed passwords.,Previous to Ansible 2.6, this was C(no) by default.
         attribute :encrypted
-        validates :encrypted, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :encrypted, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] The date at which the user's password is to expire.,If set to C('infinity'), user's password never expire.,Note that this value should be a valid SQL date and time type.
         attribute :expires
@@ -66,11 +66,11 @@ module Ansible
 
         # @return [:yes, :no, nil] If C(yes), don't inspect database for password changes. Effective when C(pg_authid) is not accessible (such as AWS RDS). Otherwise, make password changes as necessary.
         attribute :no_password_changes
-        validates :no_password_changes, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :no_password_changes, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:disable, :allow, :prefer, :require, :"verify-ca", :"verify-full", nil] Determines whether or with what priority a secure SSL TCP/IP connection will be negotiated with the server.,See U(https://www.postgresql.org/docs/current/static/libpq-ssl.html) for more information on the modes.,Default of C(prefer) matches libpq default.
         attribute :ssl_mode
-        validates :ssl_mode, inclusion: {:in=>[:disable, :allow, :prefer, :require, :"verify-ca", :"verify-full"], :message=>"%{value} needs to be :disable, :allow, :prefer, :require, :\"verify-ca\", :\"verify-full\""}, allow_nil: true
+        validates :ssl_mode, expression_inclusion: {:in=>[:disable, :allow, :prefer, :require, :"verify-ca", :"verify-full"], :message=>"%{value} needs to be :disable, :allow, :prefer, :require, :\"verify-ca\", :\"verify-full\""}, allow_nil: true
 
         # @return [Object, nil] Specifies the name of a file containing SSL certificate authority (CA) certificate(s). If the file exists, the server's certificate will be verified to be signed by one of these authorities.
         attribute :ssl_rootcert