ansible-ruby 1.0.22 → 1.0.23

data/lib/ansible/ruby/modules/generated/cloud/azure/azure_rm_virtualmachine_extension.rb

@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:absent, :present, nil] Assert the state of the vm extension. Use 'present' to create or update a vm extension and 'absent' to delete a vm extension.
         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] Valid azure location. Defaults to location of the resource group.
         attribute :location

data/lib/ansible/ruby/modules/generated/cloud/azure/azure_rm_virtualmachine_scaleset.rb

@@ -18,7 +18,7 @@ module Ansible
 
         # @return [:absent, :present, nil] Assert the state of the virtual machine scale set.,State 'present' will check that the machine exists with the requested configuration. If the configuration of the existing machine does not match, the machine will be updated. state.,State 'absent' will remove the virtual machine scale set.
         attribute :state
-        validates :state, inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:absent, :present], :message=>"%{value} needs to be :absent, :present"}, allow_nil: true
 
         # @return [Object, nil] Valid Azure location. Defaults to location of the resource group.
         attribute :location
@@ -36,11 +36,11 @@ module Ansible
 
         # @return [:Basic, :Standard, nil] SKU Tier.
         attribute :tier
-        validates :tier, inclusion: {:in=>[:Basic, :Standard], :message=>"%{value} needs to be :Basic, :Standard"}, allow_nil: true
+        validates :tier, expression_inclusion: {:in=>[:Basic, :Standard], :message=>"%{value} needs to be :Basic, :Standard"}, allow_nil: true
 
         # @return [:Manual, :Automatic, nil] Upgrade policy.
         attribute :upgrade_policy
-        validates :upgrade_policy, inclusion: {:in=>[:Manual, :Automatic], :message=>"%{value} needs to be :Manual, :Automatic"}, allow_nil: true
+        validates :upgrade_policy, expression_inclusion: {:in=>[:Manual, :Automatic], :message=>"%{value} needs to be :Manual, :Automatic"}, allow_nil: true
 
         # @return [String, nil] Admin username used to access the host after it is created. Required when creating a VM.
         attribute :admin_username
@@ -52,7 +52,7 @@ module Ansible
 
         # @return [Boolean, nil] When the os_type is Linux, setting ssh_password_enabled to false will disable SSH password authentication and require use of SSH keys.
         attribute :ssh_password_enabled
-        validates :ssh_password_enabled, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :ssh_password_enabled, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Array<Hash>, Hash, nil] For os_type Linux provide a list of SSH keys. Each item in the list should be a dictionary where the dictionary contains two keys: path and key_data. Set the path to the default location of the authorized_keys files. On an Enterprise Linux host, for example, the path will be /home/<admin username>/.ssh/authorized_keys. Set key_data to the actual value of the public key.
         attribute :ssh_public_keys
@@ -64,15 +64,15 @@ module Ansible
 
         # @return [:ReadOnly, :ReadWrite, nil] Type of OS disk caching.
         attribute :os_disk_caching
-        validates :os_disk_caching, inclusion: {:in=>[:ReadOnly, :ReadWrite], :message=>"%{value} needs to be :ReadOnly, :ReadWrite"}, allow_nil: true
+        validates :os_disk_caching, expression_inclusion: {:in=>[:ReadOnly, :ReadWrite], :message=>"%{value} needs to be :ReadOnly, :ReadWrite"}, allow_nil: true
 
         # @return [:Windows, :Linux, nil] Base type of operating system.
         attribute :os_type
-        validates :os_type, inclusion: {:in=>[:Windows, :Linux], :message=>"%{value} needs to be :Windows, :Linux"}, allow_nil: true
+        validates :os_type, expression_inclusion: {:in=>[:Windows, :Linux], :message=>"%{value} needs to be :Windows, :Linux"}, allow_nil: true
 
         # @return [:Standard_LRS, :Premium_LRS, nil] Managed disk type.
         attribute :managed_disk_type
-        validates :managed_disk_type, inclusion: {:in=>[:Standard_LRS, :Premium_LRS], :message=>"%{value} needs to be :Standard_LRS, :Premium_LRS"}, allow_nil: true
+        validates :managed_disk_type, expression_inclusion: {:in=>[:Standard_LRS, :Premium_LRS], :message=>"%{value} needs to be :Standard_LRS, :Premium_LRS"}, allow_nil: true
 
         # @return [Array<Hash>, Hash, nil] Describes list of data disks.
         attribute :data_disks

data/lib/ansible/ruby/modules/generated/cloud/azure/azure_rm_virtualmachine_scaleset_facts.rb

@@ -22,7 +22,7 @@ module Ansible
 
         # @return [:curated, :raw, nil] Format of the data returned.,If C(raw) is selected information will be returned in raw format from Azure Python SDK.,If C(curated) is selected the structure will be identical to input parameters of azure_rm_virtualmachine_scaleset module.,In Ansible 2.5 and lower facts are always returned in raw format.,Please note that this option will be deprecated in 2.10 when curated format will become the only supported format.
         attribute :format
-        validates :format, inclusion: {:in=>[:curated, :raw], :message=>"%{value} needs to be :curated, :raw"}, allow_nil: true
+        validates :format, expression_inclusion: {:in=>[:curated, :raw], :message=>"%{value} needs to be :curated, :raw"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/cloud/azure/azure_rm_virtualnetwork.rb

@@ -29,15 +29,15 @@ module Ansible
 
         # @return [:yes, :no, nil] Use with state present to remove any existing address_prefixes.
         attribute :purge_address_prefixes
-        validates :purge_address_prefixes, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :purge_address_prefixes, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:yes, :no, nil] Use with state present to remove existing DNS servers, reverting to default Azure servers. Mutually exclusive with dns_servers.
         attribute :purge_dns_servers
-        validates :purge_dns_servers, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :purge_dns_servers, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [:absent, :present, nil] Assert the state of the virtual network. Use 'present' to create or update and 'absent' to delete.
         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/azure/azure_rm_webapp.rb

@@ -42,7 +42,7 @@ module Ansible
 
         # @return [Boolean, nil] True to enable client affinity; False to stop sending session affinity cookies, which route client requests in the same session to the same instance.
         attribute :client_affinity_enabled
-        validates :client_affinity_enabled, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :client_affinity_enabled, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Symbol, nil] Configures web site to accept only https requests.
         attribute :https_only
@@ -73,7 +73,7 @@ module Ansible
 
         # @return [:absent, :present, nil] Assert the state of the Web App.,Use 'present' to create or update a Web App and 'absent' to delete it.
         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/centurylink/clc_aa_policy.rb

@@ -18,11 +18,11 @@ module Ansible
 
         # @return [:present, :absent, nil] Whether to create or delete the policy.
         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] Whether to wait for the tasks to finish before returning.
         attribute :wait
-        validates :wait, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :wait, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/cloud/centurylink/clc_alert_policy.rb

@@ -24,7 +24,7 @@ module Ansible
 
         # @return [:cpu, :memory, :disk, nil] The metric on which to measure the condition that will trigger the alert. This is required for state 'present'
         attribute :metric
-        validates :metric, inclusion: {:in=>[:cpu, :memory, :disk], :message=>"%{value} needs to be :cpu, :memory, :disk"}, allow_nil: true
+        validates :metric, expression_inclusion: {:in=>[:cpu, :memory, :disk], :message=>"%{value} needs to be :cpu, :memory, :disk"}, allow_nil: true
 
         # @return [Object, nil] The length of time in minutes that the condition must exceed the threshold. This is required for state 'present'
         attribute :duration
@@ -34,7 +34,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Whether to create or delete the policy.
         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/centurylink/clc_blueprint_package.rb

@@ -21,11 +21,11 @@ module Ansible
 
         # @return [:present, nil] Whether to install or un-install the package. Currently it supports only "present" for install action.
         attribute :state
-        validates :state, inclusion: {:in=>[:present], :message=>"%{value} needs to be :present"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present], :message=>"%{value} needs to be :present"}, allow_nil: true
 
         # @return [Boolean, nil] Whether to wait for the tasks to finish before returning.
         attribute :wait
-        validates :wait, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :wait, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/cloud/centurylink/clc_firewall_policy.rb

@@ -14,7 +14,7 @@ module Ansible
 
         # @return [:present, :absent, nil] Whether to create or delete the firewall policy
         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 list  of source addresses for traffic on the originating firewall. This is required when state is 'present'
         attribute :source
@@ -24,7 +24,7 @@ module Ansible
 
         # @return [:any, :icmp, :"TCP/123", :"UDP/123", :"TCP/123-456", :"UDP/123-456", nil] The list of ports associated with the policy. TCP and UDP can take in single ports or port ranges.
         attribute :ports
-        validates :ports, inclusion: {:in=>[:any, :icmp, :"TCP/123", :"UDP/123", :"TCP/123-456", :"UDP/123-456"], :message=>"%{value} needs to be :any, :icmp, :\"TCP/123\", :\"UDP/123\", :\"TCP/123-456\", :\"UDP/123-456\""}, allow_nil: true
+        validates :ports, expression_inclusion: {:in=>[:any, :icmp, :"TCP/123", :"UDP/123", :"TCP/123-456", :"UDP/123-456"], :message=>"%{value} needs to be :any, :icmp, :\"TCP/123\", :\"UDP/123\", :\"TCP/123-456\", :\"UDP/123-456\""}, allow_nil: true
 
         # @return [Object, nil] Id of the firewall policy. This is required to update or delete an existing firewall policy
         attribute :firewall_policy_id
@@ -38,11 +38,11 @@ module Ansible
 
         # @return [:yes, :no, nil] Whether to wait for the provisioning tasks to finish before returning.
         attribute :wait
-        validates :wait, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :wait, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Boolean, nil] Whether the firewall policy is enabled or disabled
         attribute :enabled
-        validates :enabled, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :enabled, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/cloud/centurylink/clc_group.rb

@@ -23,11 +23,11 @@ module Ansible
 
         # @return [:present, :absent, nil] Whether to create or delete the group
         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] Whether to wait for the tasks to finish before returning.
         attribute :wait
-        validates :wait, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :wait, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/cloud/centurylink/clc_loadbalancer.rb

@@ -25,26 +25,26 @@ module Ansible
 
         # @return [:leastConnection, :roundRobin, nil] -The balancing method for the load balancer pool
         attribute :method
-        validates :method, inclusion: {:in=>[:leastConnection, :roundRobin], :message=>"%{value} needs to be :leastConnection, :roundRobin"}, allow_nil: true
+        validates :method, expression_inclusion: {:in=>[:leastConnection, :roundRobin], :message=>"%{value} needs to be :leastConnection, :roundRobin"}, allow_nil: true
 
         # @return [:standard, :sticky, nil] The persistence method for the load balancer
         attribute :persistence
-        validates :persistence, inclusion: {:in=>[:standard, :sticky], :message=>"%{value} needs to be :standard, :sticky"}, allow_nil: true
+        validates :persistence, expression_inclusion: {:in=>[:standard, :sticky], :message=>"%{value} needs to be :standard, :sticky"}, allow_nil: true
 
         # @return [80, 443, nil] Port to configure on the public-facing side of the load balancer pool
         attribute :port
-        validates :port, inclusion: {:in=>[80, 443], :message=>"%{value} needs to be 80, 443"}, allow_nil: true
+        validates :port, expression_inclusion: {:in=>[80, 443], :message=>"%{value} needs to be 80, 443"}, allow_nil: true
 
         # @return [Object, nil] A list of nodes that needs to be added to the load balancer pool
         attribute :nodes
 
         # @return [:enabled, :disabled, nil] The status of the loadbalancer
         attribute :status
-        validates :status, inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
+        validates :status, expression_inclusion: {:in=>[:enabled, :disabled], :message=>"%{value} needs to be :enabled, :disabled"}, allow_nil: true
 
         # @return [:present, :absent, :port_absent, :nodes_present, :nodes_absent, nil] Whether to create or delete the load balancer pool
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent, :port_absent, :nodes_present, :nodes_absent], :message=>"%{value} needs to be :present, :absent, :port_absent, :nodes_present, :nodes_absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent, :port_absent, :nodes_present, :nodes_absent], :message=>"%{value} needs to be :present, :absent, :port_absent, :nodes_present, :nodes_absent"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/cloud/centurylink/clc_modify_server.rb

@@ -36,11 +36,11 @@ module Ansible
 
         # @return [:present, :absent, nil] The state to insure that the provided resources are in.
         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 to wait for the provisioning tasks to finish before returning.
         attribute :wait
-        validates :wait, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :wait, 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/centurylink/clc_publicip.rb

@@ -10,7 +10,7 @@ module Ansible
       class Clc_publicip < Base
         # @return [:TCP, :UDP, :ICMP, nil] The protocol that the public IP will listen for.
         attribute :protocol
-        validates :protocol, inclusion: {:in=>[:TCP, :UDP, :ICMP], :message=>"%{value} needs to be :TCP, :UDP, :ICMP"}, allow_nil: true
+        validates :protocol, expression_inclusion: {:in=>[:TCP, :UDP, :ICMP], :message=>"%{value} needs to be :TCP, :UDP, :ICMP"}, allow_nil: true
 
         # @return [Object, nil] A list of ports to expose. This is required when state is 'present'
         attribute :ports
@@ -21,11 +21,11 @@ module Ansible
 
         # @return [:present, :absent, nil] Determine whether to create or delete public IPs. If present module will not create a second public ip if one already exists.
         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 to wait for the tasks to finish before returning.
         attribute :wait
-        validates :wait, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :wait, 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/centurylink/clc_server.rb

@@ -13,7 +13,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Whether to add a public ip to the server
         attribute :add_public_ip
-        validates :add_public_ip, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :add_public_ip, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Object, nil] The account alias to provision the servers under.
         attribute :alias
@@ -67,7 +67,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Whether to create the server as 'Managed' or not.
         attribute :managed_os
-        validates :managed_os, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :managed_os, expression_inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
 
         # @return [Integer, nil] Memory in GB.
         attribute :memory
@@ -91,7 +91,7 @@ module Ansible
 
         # @return [:TCP, :UDP, :ICMP, nil] The protocol to use for the public ip if add_public_ip is set to True.
         attribute :public_ip_protocol
-        validates :public_ip_protocol, inclusion: {:in=>[:TCP, :UDP, :ICMP], :message=>"%{value} needs to be :TCP, :UDP, :ICMP"}, allow_nil: true
+        validates :public_ip_protocol, expression_inclusion: {:in=>[:TCP, :UDP, :ICMP], :message=>"%{value} needs to be :TCP, :UDP, :ICMP"}, allow_nil: true
 
         # @return [Object, nil] A list of ports to allow on the firewall to the servers public ip, if add_public_ip is set to True.
         attribute :public_ip_ports
@@ -107,11 +107,11 @@ module Ansible
 
         # @return [:present, :absent, :started, :stopped, nil] The state to insure that the provided resources are in.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent, :started, :stopped], :message=>"%{value} needs to be :present, :absent, :started, :stopped"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent, :started, :stopped], :message=>"%{value} needs to be :present, :absent, :started, :stopped"}, allow_nil: true
 
         # @return [:standard, :hyperscale, nil] The type of storage to attach to the server.
         attribute :storage_type
-        validates :storage_type, inclusion: {:in=>[:standard, :hyperscale], :message=>"%{value} needs to be :standard, :hyperscale"}, allow_nil: true
+        validates :storage_type, expression_inclusion: {:in=>[:standard, :hyperscale], :message=>"%{value} needs to be :standard, :hyperscale"}, allow_nil: true
 
         # @return [String, nil] The template to use for server creation.  Will search for a template if a partial string is provided. This is required when state is 'present'
         attribute :template
@@ -122,18 +122,18 @@ module Ansible
 
         # @return [:standard, :hyperscale, :bareMetal, nil] The type of server to create.
         attribute :type
-        validates :type, inclusion: {:in=>[:standard, :hyperscale, :bareMetal], :message=>"%{value} needs to be :standard, :hyperscale, :bareMetal"}, allow_nil: true
+        validates :type, expression_inclusion: {:in=>[:standard, :hyperscale, :bareMetal], :message=>"%{value} needs to be :standard, :hyperscale, :bareMetal"}, allow_nil: true
 
         # @return [Object, nil] Only required for bare metal servers. Specifies the identifier for the specific configuration type of bare metal server to deploy.
         attribute :configuration_id
 
         # @return [:redHat6_64Bit, :centOS6_64Bit, :windows2012R2Standard_64Bit, :ubuntu14_64Bit, nil] Only required for bare metal servers. Specifies the OS to provision with the bare metal server.
         attribute :os_type
-        validates :os_type, inclusion: {:in=>[:redHat6_64Bit, :centOS6_64Bit, :windows2012R2Standard_64Bit, :ubuntu14_64Bit], :message=>"%{value} needs to be :redHat6_64Bit, :centOS6_64Bit, :windows2012R2Standard_64Bit, :ubuntu14_64Bit"}, allow_nil: true
+        validates :os_type, expression_inclusion: {:in=>[:redHat6_64Bit, :centOS6_64Bit, :windows2012R2Standard_64Bit, :ubuntu14_64Bit], :message=>"%{value} needs to be :redHat6_64Bit, :centOS6_64Bit, :windows2012R2Standard_64Bit, :ubuntu14_64Bit"}, allow_nil: true
 
         # @return [:yes, :no, nil] Whether to wait for the provisioning tasks to finish before returning.
         attribute :wait
-        validates :wait, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :wait, 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/centurylink/clc_server_snapshot.rb

@@ -18,11 +18,11 @@ module Ansible
 
         # @return [:present, :absent, :restore, nil] The state to insure that the provided resources are in.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent, :restore], :message=>"%{value} needs to be :present, :absent, :restore"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent, :restore], :message=>"%{value} needs to be :present, :absent, :restore"}, allow_nil: true
 
         # @return [Boolean, nil] Whether to wait for the provisioning tasks to finish before returning.
         attribute :wait
-        validates :wait, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :wait, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
       end
     end
   end

data/lib/ansible/ruby/modules/generated/cloud/cloudscale/cloudscale_floating_ip.rb

@@ -13,7 +13,7 @@ module Ansible
       class Cloudscale_floating_ip < Base
         # @return [:present, :absent, nil] State of the floating IP.
         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] Floating IP address to change.,Required to assign the IP to a different server or if I(state) is absent.
         attribute :ip
@@ -21,7 +21,7 @@ module Ansible
 
         # @return [4, 6, nil] IP protocol version of the floating IP.
         attribute :ip_version
-        validates :ip_version, inclusion: {:in=>[4, 6], :message=>"%{value} needs to be 4, 6"}, allow_nil: true
+        validates :ip_version, expression_inclusion: {:in=>[4, 6], :message=>"%{value} needs to be 4, 6"}, allow_nil: true
 
         # @return [String, nil] UUID of the server assigned to this floating IP.,Required unless I(state) is absent.
         attribute :server
@@ -29,7 +29,7 @@ module Ansible
 
         # @return [56, nil] Only valid if I(ip_version) is 6.,Prefix length for the IPv6 network. Currently only a prefix of /56 can be requested. If no I(prefix_length) is present, a single address is created.
         attribute :prefix_length
-        validates :prefix_length, inclusion: {:in=>[56], :message=>"%{value} needs to be 56"}, allow_nil: true
+        validates :prefix_length, expression_inclusion: {:in=>[56], :message=>"%{value} needs to be 56"}, allow_nil: true
 
         # @return [String, nil] Reverse PTR entry for this address.,You cannot set a reverse PTR entry for IPv6 floating networks. Reverse PTR entries are only allowed for single addresses.
         attribute :reverse_ptr

data/lib/ansible/ruby/modules/generated/cloud/cloudscale/cloudscale_server.rb

@@ -13,7 +13,7 @@ module Ansible
       class Cloudscale_server < Base
         # @return [:running, :stopped, :absent, nil] State of the server
         attribute :state
-        validates :state, inclusion: {:in=>[:running, :stopped, :absent], :message=>"%{value} needs to be :running, :stopped, :absent"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:running, :stopped, :absent], :message=>"%{value} needs to be :running, :stopped, :absent"}, allow_nil: true
 
         # @return [String, nil] Name of the Server.,Either C(name) or C(uuid) are required. These options are mutually exclusive.
         attribute :name
@@ -45,15 +45,15 @@ module Ansible
 
         # @return [Boolean, nil] Attach a public network interface to the server.
         attribute :use_public_network
-        validates :use_public_network, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :use_public_network, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Boolean, nil] Attach a private network interface to the server.
         attribute :use_private_network
-        validates :use_private_network, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :use_private_network, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [Boolean, nil] Enable IPv6 on the public network interface.
         attribute :use_ipv6
-        validates :use_ipv6, inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
+        validates :use_ipv6, expression_inclusion: {:in=>[true, false], :message=>"%{value} needs to be true, false"}, allow_nil: true
 
         # @return [String, nil] UUID of another server to create an anti-affinity group with.
         attribute :anti_affinity_with

data/lib/ansible/ruby/modules/generated/cloud/cloudstack/cs_account.rb

@@ -40,7 +40,7 @@ module Ansible
 
         # @return [:user, :root_admin, :domain_admin, nil] Type of the account.
         attribute :account_type
-        validates :account_type, inclusion: {:in=>[:user, :root_admin, :domain_admin], :message=>"%{value} needs to be :user, :root_admin, :domain_admin"}, allow_nil: true
+        validates :account_type, expression_inclusion: {:in=>[:user, :root_admin, :domain_admin], :message=>"%{value} needs to be :user, :root_admin, :domain_admin"}, allow_nil: true
 
         # @return [String, nil] Domain the account is related to.
         attribute :domain
@@ -48,11 +48,11 @@ module Ansible
 
         # @return [:present, :absent, :enabled, :disabled, :locked, :unlocked, nil] State of the account.,C(unlocked) is an alias for C(enabled).
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent, :enabled, :disabled, :locked, :unlocked], :message=>"%{value} needs to be :present, :absent, :enabled, :disabled, :locked, :unlocked"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent, :enabled, :disabled, :locked, :unlocked], :message=>"%{value} needs to be :present, :absent, :enabled, :disabled, :locked, :unlocked"}, allow_nil: true
 
         # @return [:yes, :no, nil] Poll async jobs until job has finished.
         attribute :poll_async
-        validates :poll_async, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :poll_async, 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/cloudstack/cs_affinitygroup.rb

@@ -21,7 +21,7 @@ module Ansible
 
         # @return [:present, :absent, nil] State of the affinity group.
         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] Domain the affinity group is related to.
         attribute :domain
@@ -34,7 +34,7 @@ module Ansible
 
         # @return [:yes, :no, nil] Poll async jobs until job has finished.
         attribute :poll_async
-        validates :poll_async, inclusion: {:in=>[:yes, :no], :message=>"%{value} needs to be :yes, :no"}, allow_nil: true
+        validates :poll_async, 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/cloudstack/cs_cluster.rb

@@ -21,11 +21,11 @@ module Ansible
 
         # @return [:CloudManaged, :ExternalManaged, nil] Type of the cluster.,Required if C(state=present)
         attribute :cluster_type
-        validates :cluster_type, inclusion: {:in=>[:CloudManaged, :ExternalManaged], :message=>"%{value} needs to be :CloudManaged, :ExternalManaged"}, allow_nil: true
+        validates :cluster_type, expression_inclusion: {:in=>[:CloudManaged, :ExternalManaged], :message=>"%{value} needs to be :CloudManaged, :ExternalManaged"}, allow_nil: true
 
         # @return [:KVM, :VMware, :BareMetal, :XenServer, :LXC, :HyperV, :UCS, :OVM, nil] Name the hypervisor to be used.,Required if C(state=present).
         attribute :hypervisor
-        validates :hypervisor, inclusion: {:in=>[:KVM, :VMware, :BareMetal, :XenServer, :LXC, :HyperV, :UCS, :OVM], :message=>"%{value} needs to be :KVM, :VMware, :BareMetal, :XenServer, :LXC, :HyperV, :UCS, :OVM"}, allow_nil: true
+        validates :hypervisor, expression_inclusion: {:in=>[:KVM, :VMware, :BareMetal, :XenServer, :LXC, :HyperV, :UCS, :OVM], :message=>"%{value} needs to be :KVM, :VMware, :BareMetal, :XenServer, :LXC, :HyperV, :UCS, :OVM"}, allow_nil: true
 
         # @return [Object, nil] URL for the cluster
         attribute :url
@@ -41,14 +41,14 @@ module Ansible
 
         # @return [:vmwaresvs, :vmwaredvs, nil] Type of virtual switch used for guest traffic in the cluster.,Allowed values are, vmwaresvs (for VMware standard vSwitch) and vmwaredvs (for VMware distributed vSwitch)
         attribute :guest_vswitch_type
-        validates :guest_vswitch_type, inclusion: {:in=>[:vmwaresvs, :vmwaredvs], :message=>"%{value} needs to be :vmwaresvs, :vmwaredvs"}, allow_nil: true
+        validates :guest_vswitch_type, expression_inclusion: {:in=>[:vmwaresvs, :vmwaredvs], :message=>"%{value} needs to be :vmwaresvs, :vmwaredvs"}, allow_nil: true
 
         # @return [Object, nil] Name of virtual switch used for public traffic in the cluster.,This would override zone wide traffic label setting.
         attribute :public_vswitch_name
 
         # @return [:vmwaresvs, :vmwaredvs, nil] Type of virtual switch used for public traffic in the cluster.,Allowed values are, vmwaresvs (for VMware standard vSwitch) and vmwaredvs (for VMware distributed vSwitch)
         attribute :public_vswitch_type
-        validates :public_vswitch_type, inclusion: {:in=>[:vmwaresvs, :vmwaredvs], :message=>"%{value} needs to be :vmwaresvs, :vmwaredvs"}, allow_nil: true
+        validates :public_vswitch_type, expression_inclusion: {:in=>[:vmwaresvs, :vmwaredvs], :message=>"%{value} needs to be :vmwaresvs, :vmwaredvs"}, allow_nil: true
 
         # @return [Object, nil] IP address of the VSM associated with this cluster.
         attribute :vms_ip_address
@@ -70,7 +70,7 @@ module Ansible
 
         # @return [:present, :absent, :disabled, :enabled, nil] State of the cluster.
         attribute :state
-        validates :state, inclusion: {:in=>[:present, :absent, :disabled, :enabled], :message=>"%{value} needs to be :present, :absent, :disabled, :enabled"}, allow_nil: true
+        validates :state, expression_inclusion: {:in=>[:present, :absent, :disabled, :enabled], :message=>"%{value} needs to be :present, :absent, :disabled, :enabled"}, allow_nil: true
       end
     end
   end