ansible-ruby 1.0.22 → 1.0.23

data/lib/ansible/ruby/modules/generated/cloud/docker/docker_swarm.rb

@@ -19,11 +19,11 @@ module Ansible
 
         # @return [:yes, :no, nil] Use with state C(present) to force creating a new Swarm, even if already part of one.,Use with state C(absent) to Leave the swarm even if this node is a manager.
         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 [:present, :join, :absent, :remove, :inspect] Set to C(present), to create/update a new cluster.,Set to C(join), to join an existing cluster.,Set to C(absent), to leave an existing cluster.,Set to C(remove), to remove an absent node from the cluster.,Set to C(inspect) to display swarm informations.
         attribute :state
-        validates :state, presence: true, inclusion: {:in=>[:present, :join, :absent, :remove, :inspect], :message=>"%{value} needs to be :present, :join, :absent, :remove, :inspect"}
+        validates :state, presence: true, expression_inclusion: {:in=>[:present, :join, :absent, :remove, :inspect], :message=>"%{value} needs to be :present, :join, :absent, :remove, :inspect"}
 
         # @return [String, nil] Swarm id of the node to remove.,Used with I(state=remove).
         attribute :node_id
@@ -83,11 +83,11 @@ module Ansible
 
         # @return [:yes, :no, nil] Rotate the worker join token.
         attribute :rotate_worker_token
-        validates :rotate_worker_token, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :rotate_worker_token, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Rotate the manager join token.
         attribute :rotate_manager_token
-        validates :rotate_manager_token, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :rotate_manager_token, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/cloud/docker/docker_swarm_service.rb

@@ -19,7 +19,7 @@ module Ansible
 
         # @return [:present, :absent] Service state.
         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 [Object, nil] List comprised of the command and the arguments to be run inside,the container
         attribute :args
@@ -56,7 +56,7 @@ module Ansible
 
         # @return [:vip, :dnsrr, nil] Service endpoint mode.,Maps docker service --endpoint-mode option.
         attribute :endpoint_mode
-        validates :endpoint_mode, inclusion: {:in=>[:vip, :dnsrr], :message=>"%{value} needs to be :vip, :dnsrr"}, allow_nil: true
+        validates :endpoint_mode, expression_inclusion: {:in=>[:vip, :dnsrr], :message=>"%{value} needs to be :vip, :dnsrr"}, allow_nil: true
 
         # @return [Object, nil] List of the service environment variables.,Maps docker service --env option.
         attribute :env
@@ -109,7 +109,7 @@ module Ansible
 
         # @return [:none, :"on-failure", :any, nil] Restart condition of the service.,Maps docker service --restart-condition option.
         attribute :restart_policy
-        validates :restart_policy, inclusion: {:in=>[:none, :"on-failure", :any], :message=>"%{value} needs to be :none, :\"on-failure\", :any"}, allow_nil: true
+        validates :restart_policy, expression_inclusion: {:in=>[:none, :"on-failure", :any], :message=>"%{value} needs to be :none, :\"on-failure\", :any"}, allow_nil: true
 
         # @return [Integer, nil] Maximum number of service restarts.,Maps docker service --restart-max-attempts option.
         attribute :restart_policy_attempts
@@ -133,7 +133,7 @@ module Ansible
 
         # @return [:continue, :pause, nil] Action to take in case of container failure,Maps to docker service --update-failure-action option
         attribute :update_failure_action
-        validates :update_failure_action, inclusion: {:in=>[:continue, :pause], :message=>"%{value} needs to be :continue, :pause"}, allow_nil: true
+        validates :update_failure_action, expression_inclusion: {:in=>[:continue, :pause], :message=>"%{value} needs to be :continue, :pause"}, allow_nil: true
 
         # @return [Integer, nil] Time to monitor updated tasks for failures, in nanoseconds.,Maps to docker service --update-monitor option
         attribute :update_monitor
@@ -145,7 +145,7 @@ module Ansible
 
         # @return [:"stop-first", :"start-first", nil] Specifies the order of operations when rolling out an updated task.,Maps to docker service --update-order
         attribute :update_order
-        validates :update_order, inclusion: {:in=>[:"stop-first", :"start-first"], :message=>"%{value} needs to be :\"stop-first\", :\"start-first\""}, allow_nil: true
+        validates :update_order, expression_inclusion: {:in=>[:"stop-first", :"start-first"], :message=>"%{value} needs to be :\"stop-first\", :\"start-first\""}, allow_nil: true
 
         # @return [String, nil] username or UID
         attribute :user

data/lib/ansible/ruby/modules/generated/cloud/docker/docker_volume.rb

@@ -26,11 +26,11 @@ module Ansible
 
         # @return [:yes, :no, nil] With state C(present) causes the volume to be deleted and recreated if the volume already exist and the driver, driver options or labels differ. This will cause any data in the existing volume to be lost.
         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 [:absent, :present, nil] C(absent) deletes the volume.,C(present) creates the volume, if it does not already exist.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/cloud/google/gc_storage.rb

@@ -26,7 +26,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Forces an overwrite either locally on the filesystem or remotely with the object/key. Used with PUT and GET operations.
         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] This option let's the user set the canned permissions on the object/bucket that are created. The permissions that can be set are 'private', 'public-read', 'authenticated-read'.
         attribute :permission
@@ -40,7 +40,7 @@ module Ansible
 
         # @return [:get, :put, :get_url, :get_str, :delete, :create] Switches the module behaviour between upload, download, get_url (return download url) , get_str (download object as string), create (bucket) and delete (bucket).
         attribute :mode
-        validates :mode, presence: true, inclusion: {:in=>[:get, :put, :get_url, :get_str, :delete, :create], :message=>"%{value} needs to be :get, :put, :get_url, :get_str, :delete, :create"}
+        validates :mode, presence: true, expression_inclusion: {:in=>[:get, :put, :get_url, :get_str, :delete, :create], :message=>"%{value} needs to be :get, :put, :get_url, :get_str, :delete, :create"}
 
         # @return [Object] GS secret key. If not set then the value of the GS_SECRET_ACCESS_KEY environment variable is used.
         attribute :gs_secret_key

data/lib/ansible/ruby/modules/generated/cloud/google/gcdns_record.rb

@@ -10,7 +10,7 @@ module Ansible
       class Gcdns_record < Base
         # @return [:present, :absent, nil] Whether the given resource record should or should not be present.
         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] The fully-qualified domain name of the resource record.
         attribute :record
@@ -26,7 +26,7 @@ module Ansible
 
         # @return [:A, :AAAA, :CNAME, :SRV, :TXT, :SOA, :NS, :MX, :SPF, :PTR] The type of resource record to add.
         attribute :type
-        validates :type, presence: true, inclusion: {:in=>[:A, :AAAA, :CNAME, :SRV, :TXT, :SOA, :NS, :MX, :SPF, :PTR], :message=>"%{value} needs to be :A, :AAAA, :CNAME, :SRV, :TXT, :SOA, :NS, :MX, :SPF, :PTR"}
+        validates :type, presence: true, expression_inclusion: {:in=>[:A, :AAAA, :CNAME, :SRV, :TXT, :SOA, :NS, :MX, :SPF, :PTR], :message=>"%{value} needs to be :A, :AAAA, :CNAME, :SRV, :TXT, :SOA, :NS, :MX, :SPF, :PTR"}
 
         # @return [Array<String>, String, nil] The record_data to use for the resource record.,I(record_data) must be specified if I(state) is C(present) or I(overwrite) is C(True), or the module will fail.,Valid record_data vary based on the record's I(type). In addition, resource records that contain a DNS domain name in the value field (e.g., CNAME, PTR, SRV, .etc) MUST include a trailing dot in the value.,Individual string record_data for TXT records must be enclosed in double quotes.,For resource records that have the same name but different record_data (e.g., multiple A records), they must be defined as multiple list entries in a single record.
         attribute :record_data
@@ -38,7 +38,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Whether an attempt to overwrite an existing record should succeed or fail. The behavior of this option depends on I(state).,If I(state) is C(present) and I(overwrite) is C(True), this module will replace an existing resource record of the same name with the provided I(record_data). If I(state) is C(present) and I(overwrite) is C(False), this module will fail if there is an existing resource record with the same name and type, but different resource data.,If I(state) is C(absent) and I(overwrite) is C(True), this module will remove the given resource record unconditionally. If I(state) is C(absent) and I(overwrite) is C(False), this module will fail if the provided record_data do not match exactly with the existing resource record's record_data.
         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] The e-mail address for a service account with access to Google Cloud DNS.
         attribute :service_account_email

data/lib/ansible/ruby/modules/generated/cloud/google/gcdns_zone.rb

@@ -10,7 +10,7 @@ module Ansible
       class Gcdns_zone < Base
         # @return [:present, :absent, nil] Whether the given zone should or should not be present.
         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] The DNS domain name of the zone.,This is NOT the Google Cloud DNS zone ID (e.g., example-com). If you attempt to specify a zone ID, this module will attempt to create a TLD and will fail.
         attribute :zone

data/lib/ansible/ruby/modules/generated/cloud/google/gce.rb

@@ -38,7 +38,7 @@ module Ansible
 
         # @return [:bigquery, :"cloud-platform", :"compute-ro", :"compute-rw", :"useraccounts-ro", :"useraccounts-rw", :datastore, :"logging-write", :monitoring, :"sql-admin", :"storage-full", :"storage-ro", :"storage-rw", :taskqueue, :"userinfo-email", nil] service account permissions (see U(https://cloud.google.com/sdk/gcloud/reference/compute/instances/create), --scopes section for detailed information)
         attribute :service_account_permissions
-        validates :service_account_permissions, inclusion: {:in=>[:bigquery, :"cloud-platform", :"compute-ro", :"compute-rw", :"useraccounts-ro", :"useraccounts-rw", :datastore, :"logging-write", :monitoring, :"sql-admin", :"storage-full", :"storage-ro", :"storage-rw", :taskqueue, :"userinfo-email"], :message=>"%{value} needs to be :bigquery, :\"cloud-platform\", :\"compute-ro\", :\"compute-rw\", :\"useraccounts-ro\", :\"useraccounts-rw\", :datastore, :\"logging-write\", :monitoring, :\"sql-admin\", :\"storage-full\", :\"storage-ro\", :\"storage-rw\", :taskqueue, :\"userinfo-email\""}, allow_nil: true
+        validates :service_account_permissions, expression_inclusion: {:in=>[:bigquery, :"cloud-platform", :"compute-ro", :"compute-rw", :"useraccounts-ro", :"useraccounts-rw", :datastore, :"logging-write", :monitoring, :"sql-admin", :"storage-full", :"storage-ro", :"storage-rw", :taskqueue, :"userinfo-email"], :message=>"%{value} needs to be :bigquery, :\"cloud-platform\", :\"compute-ro\", :\"compute-rw\", :\"useraccounts-ro\", :\"useraccounts-rw\", :datastore, :\"logging-write\", :monitoring, :\"sql-admin\", :\"storage-full\", :\"storage-ro\", :\"storage-rw\", :taskqueue, :\"userinfo-email\""}, allow_nil: true
 
         # @return [Object, nil] path to the pem file associated with the service account email This option is deprecated. Use 'credentials_file'.
         attribute :pem_file
@@ -67,7 +67,7 @@ module Ansible
 
         # @return [:yes, :no, nil] if set, create the instance with a persistent boot disk
         attribute :persistent_boot_disk
-        validates :persistent_boot_disk, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :persistent_boot_disk, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Array<Hash>, Hash, nil] a list of persistent disks to attach to the instance; a string value gives the name of the disk; alternatively, a dictionary value can define 'name' and 'mode' ('READ_ONLY' or 'READ_WRITE'). The first entry will be the boot disk (which must be READ_WRITE).
         attribute :disks
@@ -75,7 +75,7 @@ module Ansible
 
         # @return [:active, :present, :absent, :deleted, :started, :stopped, :terminated, nil] desired state of the resource
         attribute :state
-        validates :state, inclusion: {:in=>[:active, :present, :absent, :deleted, :started, :stopped, :terminated], :message=>"%{value} needs to be :active, :present, :absent, :deleted, :started, :stopped, :terminated"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:active, :present, :absent, :deleted, :started, :stopped, :terminated], :message=>"%{value} needs to be :active, :present, :absent, :deleted, :started, :stopped, :terminated"}, allow_nil: true
 
         # @return [Array<String>, String, nil] a comma-separated list of tags to associate with the instance
         attribute :tags
@@ -87,7 +87,7 @@ module Ansible
 
         # @return [:yes, :no, nil] set to C(yes) if the instance can forward ip packets (useful for gateways)
         attribute :ip_forward
-        validates :ip_forward, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :ip_forward, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] type of external ip, ephemeral by default; alternatively, a fixed gce ip or ip name can be given. Specify 'none' if no external ip is desired.
         attribute :external_ip
@@ -95,11 +95,11 @@ module Ansible
 
         # @return [:yes, :no, nil] if set boot disk will be removed after instance destruction
         attribute :disk_auto_delete
-        validates :disk_auto_delete, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :disk_auto_delete, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] if set to C(yes), instances will be preemptible and time-limited. (requires libcloud >= 0.20.0)
         attribute :preemptible
-        validates :preemptible, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :preemptible, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Integer, nil] The size of the boot disk created for this instance (in GB)
         attribute :disk_size

data/lib/ansible/ruby/modules/generated/cloud/google/gce_eip.rb

@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:present, :absent, nil] The state the address should be in. C(present) or C(absent) are the only valid options.
         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/cloud/google/gce_img.rb

@@ -24,7 +24,7 @@ module Ansible
 
         # @return [:present, :absent, nil] desired state of the image
         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] the zone of the disk specified by source
         attribute :zone

data/lib/ansible/ruby/modules/generated/cloud/google/gce_instance_template.rb

@@ -10,7 +10,7 @@ module Ansible
       class Gce_instance_template < Base
         # @return [:present, :absent, nil] The desired state for the instance template.
         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] The name of the GCE instance template.
         attribute :name
@@ -36,7 +36,7 @@ module Ansible
 
         # @return [Boolean, nil] Indicate that the boot disk should be deleted when the Node is deleted.
         attribute :disk_auto_delete
-        validates :disk_auto_delete, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :disk_auto_delete, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [String, nil] The network to associate with the instance.
         attribute :network
@@ -47,7 +47,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Set to C(yes) to allow instance to send/receive non-matching src/dst packets.
         attribute :can_ip_forward
-        validates :can_ip_forward, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :can_ip_forward, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] The external IP address to use. If C(ephemeral), a new non-static address will be used.  If C(None), then no external address will be used.  To use an existing static IP address specify address name.
         attribute :external_ip
@@ -59,7 +59,7 @@ module Ansible
 
         # @return [:bigquery, :"cloud-platform", :"compute-ro", :"compute-rw", :"useraccounts-ro", :"useraccounts-rw", :datastore, :"logging-write", :monitoring, :"sql-admin", :"storage-full", :"storage-ro", :"storage-rw", :taskqueue, :"userinfo-email", nil] service account permissions (see U(https://cloud.google.com/sdk/gcloud/reference/compute/instances/create), --scopes section for detailed information)
         attribute :service_account_permissions
-        validates :service_account_permissions, inclusion: {:in=>[:bigquery, :"cloud-platform", :"compute-ro", :"compute-rw", :"useraccounts-ro", :"useraccounts-rw", :datastore, :"logging-write", :monitoring, :"sql-admin", :"storage-full", :"storage-ro", :"storage-rw", :taskqueue, :"userinfo-email"], :message=>"%{value} needs to be :bigquery, :\"cloud-platform\", :\"compute-ro\", :\"compute-rw\", :\"useraccounts-ro\", :\"useraccounts-rw\", :datastore, :\"logging-write\", :monitoring, :\"sql-admin\", :\"storage-full\", :\"storage-ro\", :\"storage-rw\", :taskqueue, :\"userinfo-email\""}, allow_nil: true
+        validates :service_account_permissions, expression_inclusion: {:in=>[:bigquery, :"cloud-platform", :"compute-ro", :"compute-rw", :"useraccounts-ro", :"useraccounts-rw", :datastore, :"logging-write", :monitoring, :"sql-admin", :"storage-full", :"storage-ro", :"storage-rw", :taskqueue, :"userinfo-email"], :message=>"%{value} needs to be :bigquery, :\"cloud-platform\", :\"compute-ro\", :\"compute-rw\", :\"useraccounts-ro\", :\"useraccounts-rw\", :datastore, :\"logging-write\", :monitoring, :\"sql-admin\", :\"storage-full\", :\"storage-ro\", :\"storage-rw\", :taskqueue, :\"userinfo-email\""}, allow_nil: true
 
         # @return [Object, nil] Defines whether the instance should be automatically restarted when it is terminated by Compute Engine.
         attribute :automatic_restart

data/lib/ansible/ruby/modules/generated/cloud/google/gce_lb.rb

@@ -45,7 +45,7 @@ module Ansible
 
         # @return [:tcp, :udp, nil] the protocol used for the load-balancer packet forwarding, tcp or udp
         attribute :protocol
-        validates :protocol, inclusion: {:in=>[:tcp, :udp], :message=>"%{value} needs to be :tcp, :udp"}, allow_nil: true
+        validates :protocol, expression_inclusion: {:in=>[:tcp, :udp], :message=>"%{value} needs to be :tcp, :udp"}, allow_nil: true
 
         # @return [String, nil] the GCE region where the load-balancer is defined
         attribute :region
@@ -63,7 +63,7 @@ module Ansible
 
         # @return [:active, :present, :absent, :deleted, nil] desired state of the LB
         attribute :state
-        validates :state, inclusion: {:in=>[:active, :present, :absent, :deleted], :message=>"%{value} needs to be :active, :present, :absent, :deleted"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:active, :present, :absent, :deleted], :message=>"%{value} needs to be :active, :present, :absent, :deleted"}, allow_nil: true
 
         # @return [Object, nil] service account email
         attribute :service_account_email

data/lib/ansible/ruby/modules/generated/cloud/google/gce_mig.rb

@@ -29,7 +29,7 @@ module Ansible
 
         # @return [:absent, :present, nil] desired state of the resource
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
 
         # @return [Object] The GCE zone to use for this Managed Instance Group.
         attribute :zone

data/lib/ansible/ruby/modules/generated/cloud/google/gce_net.rb

@@ -35,7 +35,7 @@ module Ansible
 
         # @return [:active, :present, :absent, :deleted, nil] desired state of the network or firewall
         attribute :state
-        validates :state, inclusion: {:in=>[:active, :present, :absent, :deleted], :message=>"%{value} needs to be :active, :present, :absent, :deleted"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:active, :present, :absent, :deleted], :message=>"%{value} needs to be :active, :present, :absent, :deleted"}, allow_nil: true
 
         # @return [Object, nil] service account email
         attribute :service_account_email
@@ -51,7 +51,7 @@ module Ansible
 
         # @return [:legacy, :auto, :custom, nil] network mode for Google Cloud C(legacy) indicates a network with an IP address range; C(auto) automatically generates subnetworks in different regions; C(custom) uses networks to group subnets of user specified IP address ranges https://cloud.google.com/compute/docs/networking#network_types
         attribute :mode
-        validates :mode, inclusion: {:in=>[:legacy, :auto, :custom], :message=>"%{value} needs to be :legacy, :auto, :custom"}, allow_nil: true
+        validates :mode, expression_inclusion: {:in=>[:legacy, :auto, :custom], :message=>"%{value} needs to be :legacy, :auto, :custom"}, allow_nil: true
 
         # @return [String, nil] name of subnet to create
         attribute :subnet_name

data/lib/ansible/ruby/modules/generated/cloud/google/gce_pd.rb

@@ -10,7 +10,7 @@ module Ansible
       class Gce_pd < Base
         # @return [:yes, :no, nil] do not destroy the disk, merely detach it from an instance
         attribute :detach_only
-        validates :detach_only, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :detach_only, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [String, nil] instance name if you wish to attach or detach the disk
         attribute :instance_name
@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:READ_WRITE, :READ_ONLY, nil] GCE mount mode of disk, READ_ONLY (default) or READ_WRITE
         attribute :mode
-        validates :mode, inclusion: {:in=>[:READ_WRITE, :READ_ONLY], :message=>"%{value} needs to be :READ_WRITE, :READ_ONLY"}, allow_nil: true
+        validates :mode, expression_inclusion: {:in=>[:READ_WRITE, :READ_ONLY], :message=>"%{value} needs to be :READ_WRITE, :READ_ONLY"}, allow_nil: true
 
         # @return [String] name of the disk
         attribute :name
@@ -36,7 +36,7 @@ module Ansible
 
         # @return [:active, :present, :absent, :deleted, nil] desired state of the persistent disk
         attribute :state
-        validates :state, inclusion: {:in=>[:active, :present, :absent, :deleted], :message=>"%{value} needs to be :active, :present, :absent, :deleted"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:active, :present, :absent, :deleted], :message=>"%{value} needs to be :active, :present, :absent, :deleted"}, allow_nil: true
 
         # @return [String, nil] zone in which to create the disk
         attribute :zone
@@ -56,11 +56,11 @@ module Ansible
 
         # @return [:"pd-standard", :"pd-ssd", nil] type of disk provisioned
         attribute :disk_type
-        validates :disk_type, inclusion: {:in=>[:"pd-standard", :"pd-ssd"], :message=>"%{value} needs to be :\"pd-standard\", :\"pd-ssd\""}, allow_nil: true
+        validates :disk_type, expression_inclusion: {:in=>[:"pd-standard", :"pd-ssd"], :message=>"%{value} needs to be :\"pd-standard\", :\"pd-ssd\""}, allow_nil: true
 
         # @return [:yes, :no, nil] If C(yes), deletes the volume when instance is terminated
         attribute :delete_on_termination
-        validates :delete_on_termination, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :delete_on_termination, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/cloud/google/gce_snapshot.rb

@@ -22,7 +22,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Whether a snapshot should be C(present) or 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] GCP service account email for the project where the instance resides
         attribute :service_account_email

data/lib/ansible/ruby/modules/generated/cloud/google/gce_tag.rb

@@ -22,7 +22,7 @@ module Ansible
 
         # @return [:absent, :present, nil] Desired state of the tags.
         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 zone of the disk specified by source.
         attribute :zone

data/lib/ansible/ruby/modules/generated/cloud/google/gcp_backend_service.rb

@@ -48,7 +48,7 @@ module Ansible
 
         # @return [:absent, :present, nil] Desired state of the resource
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/cloud/google/gcp_compute_address.rb

@@ -12,14 +12,14 @@ module Ansible
       class Gcp_compute_address < Base
         # @return [:present, :absent, nil] Whether the given object should exist in GCP
         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] The static external IP address represented by this resource. Only IPv4 is supported. An address may only be specified for INTERNAL address types. The IP address must be inside the specified subnetwork, if any.
         attribute :address
 
         # @return [:INTERNAL, :EXTERNAL, nil] The type of address to reserve, either INTERNAL or EXTERNAL.,If unspecified, defaults to EXTERNAL.
         attribute :address_type
-        validates :address_type, inclusion: {:in=>[:INTERNAL, :EXTERNAL], :message=>"%{value} needs to be :INTERNAL, :EXTERNAL"}, allow_nil: true
+        validates :address_type, expression_inclusion: {:in=>[:INTERNAL, :EXTERNAL], :message=>"%{value} needs to be :INTERNAL, :EXTERNAL"}, allow_nil: true
 
         # @return [Object, nil] An optional description of this resource.
         attribute :description

data/lib/ansible/ruby/modules/generated/cloud/google/gcp_compute_backend_bucket.rb

@@ -11,7 +11,7 @@ module Ansible
       class Gcp_compute_backend_bucket < Base
         # @return [:present, :absent, nil] Whether the given object should exist in GCP
         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] Cloud Storage bucket name.
         attribute :bucket_name

data/lib/ansible/ruby/modules/generated/cloud/google/gcp_compute_backend_service.rb

@@ -10,7 +10,7 @@ module Ansible
       class Gcp_compute_backend_service < Base
         # @return [:present, :absent, nil] Whether the given object should exist in GCP
         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] Lifetime of cookies in seconds if session_affinity is GENERATED_COOKIE. If set to 0, the cookie is non-persistent and lasts only until the end of the browser session (or equivalent). The maximum allowed value for TTL is one day.,When the load balancing scheme is INTERNAL, this field is not used.
         attribute :affinity_cookie_ttl_sec
@@ -41,7 +41,7 @@ module Ansible
 
         # @return [:INTERNAL, :EXTERNAL, nil] Indicates whether the backend service will be used with internal or external load balancing. A backend service created for one type of load balancing cannot be used with the other.
         attribute :load_balancing_scheme
-        validates :load_balancing_scheme, inclusion: {:in=>[:INTERNAL, :EXTERNAL], :message=>"%{value} needs to be :INTERNAL, :EXTERNAL"}, allow_nil: true
+        validates :load_balancing_scheme, expression_inclusion: {:in=>[:INTERNAL, :EXTERNAL], :message=>"%{value} needs to be :INTERNAL, :EXTERNAL"}, allow_nil: true
 
         # @return [String, nil] Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.
         attribute :name
@@ -52,14 +52,14 @@ module Ansible
 
         # @return [:HTTP, :HTTPS, :TCP, :SSL, nil] The protocol this BackendService uses to communicate with backends.,Possible values are HTTP, HTTPS, TCP, and SSL. The default is HTTP.,For internal load balancing, the possible values are TCP and UDP, and the default is TCP.
         attribute :protocol
-        validates :protocol, inclusion: {:in=>[:HTTP, :HTTPS, :TCP, :SSL], :message=>"%{value} needs to be :HTTP, :HTTPS, :TCP, :SSL"}, allow_nil: true
+        validates :protocol, expression_inclusion: {:in=>[:HTTP, :HTTPS, :TCP, :SSL], :message=>"%{value} needs to be :HTTP, :HTTPS, :TCP, :SSL"}, allow_nil: true
 
         # @return [Object, nil] The region where the regional backend service resides.,This field is not applicable to global backend services.
         attribute :region
 
         # @return [:NONE, :CLIENT_IP, :GENERATED_COOKIE, :CLIENT_IP_PROTO, :CLIENT_IP_PORT_PROTO, nil] Type of session affinity to use. The default is NONE.,When the load balancing scheme is EXTERNAL, can be NONE, CLIENT_IP, or GENERATED_COOKIE.,When the load balancing scheme is INTERNAL, can be NONE, CLIENT_IP, CLIENT_IP_PROTO, or CLIENT_IP_PORT_PROTO.,When the protocol is UDP, this field is not used.
         attribute :session_affinity
-        validates :session_affinity, inclusion: {:in=>[:NONE, :CLIENT_IP, :GENERATED_COOKIE, :CLIENT_IP_PROTO, :CLIENT_IP_PORT_PROTO], :message=>"%{value} needs to be :NONE, :CLIENT_IP, :GENERATED_COOKIE, :CLIENT_IP_PROTO, :CLIENT_IP_PORT_PROTO"}, allow_nil: true
+        validates :session_affinity, expression_inclusion: {:in=>[:NONE, :CLIENT_IP, :GENERATED_COOKIE, :CLIENT_IP_PROTO, :CLIENT_IP_PORT_PROTO], :message=>"%{value} needs to be :NONE, :CLIENT_IP, :GENERATED_COOKIE, :CLIENT_IP_PROTO, :CLIENT_IP_PORT_PROTO"}, allow_nil: true
 
         # @return [Integer, nil] How many seconds to wait for the backend before considering it a failed request. Default is 30 seconds. Valid range is [1, 86400].
         attribute :timeout_sec

data/lib/ansible/ruby/modules/generated/cloud/google/gcp_compute_disk.rb

@@ -12,7 +12,7 @@ module Ansible
       class Gcp_compute_disk < Base
         # @return [:present, :absent, nil] Whether the given object should exist in GCP
         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] An optional description of this resource. Provide this property when you create the resource.
         attribute :description

data/lib/ansible/ruby/modules/generated/cloud/google/gcp_compute_firewall.rb

@@ -12,7 +12,7 @@ module Ansible
       class Gcp_compute_firewall < Base
         # @return [:present, :absent, nil] Whether the given object should exist in GCP
         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<Hash>, Hash, nil] The list of ALLOW rules specified by this firewall. Each rule specifies a protocol and port-range tuple that describes a permitted connection.
         attribute :allowed

data/lib/ansible/ruby/modules/generated/cloud/google/gcp_compute_forwarding_rule.rb

@@ -10,7 +10,7 @@ module Ansible
       class Gcp_compute_forwarding_rule < Base
         # @return [:present, :absent, nil] Whether the given object should exist in GCP
         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] An optional description of this resource. Provide this property when you create the resource.
         attribute :description
@@ -21,18 +21,18 @@ module Ansible
 
         # @return [:TCP, :UDP, :ESP, :AH, :SCTP, :ICMP, nil] The IP protocol to which this rule applies. Valid options are TCP, UDP, ESP, AH, SCTP or ICMP.,When the load balancing scheme is INTERNAL, only TCP and UDP are valid.
         attribute :ip_protocol
-        validates :ip_protocol, inclusion: {:in=>[:TCP, :UDP, :ESP, :AH, :SCTP, :ICMP], :message=>"%{value} needs to be :TCP, :UDP, :ESP, :AH, :SCTP, :ICMP"}, allow_nil: true
+        validates :ip_protocol, expression_inclusion: {:in=>[:TCP, :UDP, :ESP, :AH, :SCTP, :ICMP], :message=>"%{value} needs to be :TCP, :UDP, :ESP, :AH, :SCTP, :ICMP"}, allow_nil: true
 
         # @return [Object, nil] A reference to a BackendService to receive the matched traffic.,This is used for internal load balancing.,(not used for external load balancing) .
         attribute :backend_service
 
         # @return [:IPV4, :IPV6, nil] The IP Version that will be used by this forwarding rule. Valid options are IPV4 or IPV6. This can only be specified for a global forwarding rule.
         attribute :ip_version
-        validates :ip_version, inclusion: {:in=>[:IPV4, :IPV6], :message=>"%{value} needs to be :IPV4, :IPV6"}, allow_nil: true
+        validates :ip_version, expression_inclusion: {:in=>[:IPV4, :IPV6], :message=>"%{value} needs to be :IPV4, :IPV6"}, allow_nil: true
 
         # @return [:INTERNAL, :EXTERNAL, nil] This signifies what the ForwardingRule will be used for and can only take the following values: INTERNAL, EXTERNAL The value of INTERNAL means that this will be used for Internal Network Load Balancing (TCP, UDP). The value of EXTERNAL means that this will be used for External Load Balancing (HTTP(S) LB, External TCP/UDP LB, SSL Proxy) .
         attribute :load_balancing_scheme
-        validates :load_balancing_scheme, inclusion: {:in=>[:INTERNAL, :EXTERNAL], :message=>"%{value} needs to be :INTERNAL, :EXTERNAL"}, allow_nil: true
+        validates :load_balancing_scheme, expression_inclusion: {:in=>[:INTERNAL, :EXTERNAL], :message=>"%{value} needs to be :INTERNAL, :EXTERNAL"}, allow_nil: true
 
         # @return [String] Name of the resource; provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.
         attribute :name