fog-google 0.1.3 → 0.2.0

data/lib/fog/{google/models/compute → compute/google/models}/address.rb

@@ -1,5 +1,3 @@
-require 'fog/core/model'
-
 module Fog
   module Compute
     class Google
@@ -13,20 +11,20 @@ module Fog
         attribute :kind
         attribute :id
         attribute :address
-        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
         attribute :description
         attribute :region
-        attribute :self_link, :aliases => 'selfLink'
+        attribute :self_link, :aliases => "selfLink"
         attribute :status
         attribute :users
 
-        IN_USE_STATE   = 'IN_USE'
-        RESERVED_STATE = 'RESERVED'
+        IN_USE_STATE   = "IN_USE"
+        RESERVED_STATE = "RESERVED"
 
         def server
-          return nil if !in_use? || self.users.nil? || self.users.empty?
+          return nil if !in_use? || users.nil? || users.empty?
 
-          service.servers.get(self.users.first.split('/')[-1])
+          service.servers.get(users.first.split("/")[-1])
         end
 
         def server=(server)
@@ -37,55 +35,53 @@ module Fog
         def save
           requires :identity, :region
 
-          data = service.insert_address(identity, self.region, self.attributes)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], nil, data.body['region'])
+          data = service.insert_address(identity, region, attributes)
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], nil, data.body["region"])
           operation.wait_for { !pending? }
           reload
         end
 
-        def destroy(async=true)
+        def destroy(async = true)
           requires :identity, :region
 
-          data = service.delete_address(identity, self.region.split('/')[-1])
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], nil, data.body['region'])
-          unless async
-            operation.wait_for { ready? }
-          end
+          data = service.delete_address(identity, region.split("/")[-1])
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], nil, data.body["region"])
+          operation.wait_for { ready? } unless async
           operation
         end
 
         def reload
           requires :identity, :region
 
-          data = collection.get(identity, self.region.split('/')[-1])
+          data = collection.get(identity, region.split("/")[-1])
           merge_attributes(data.attributes)
           self
         end
 
         def in_use?
-          self.status == IN_USE_STATE
+          status == IN_USE_STATE
         end
 
         private
 
         def associate(server)
-          nic = server.network_interfaces.first['name']
-          data = service.add_server_access_config(server.name, server.zone_name, nic, :address => self.address)
-          Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
+          nic = server.network_interfaces.first["name"]
+          data = service.add_server_access_config(server.name, server.zone_name, nic, :address => address)
+          Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
         end
 
         def disassociate
-          return nil if !in_use? || self.users.nil? || self.users.empty?
+          return nil if !in_use? || users.nil? || users.empty?
 
           # An address can only be associated with one server at a time
-          server = service.servers.get(self.users.first.split('/')[-1])
-          nic = server.network_interfaces.first['name']
-          unless server.network_interfaces.first['accessConfigs'].nil? ||
-                 server.network_interfaces.first['accessConfigs'].empty?
-            access_config = server.network_interfaces.first['accessConfigs'].first['name']
+          server = service.servers.get(users.first.split("/")[-1])
+          nic = server.network_interfaces.first["name"]
+          unless server.network_interfaces.first["accessConfigs"].nil? ||
+                 server.network_interfaces.first["accessConfigs"].empty?
+            access_config = server.network_interfaces.first["accessConfigs"].first["name"]
             data = service.delete_server_access_config(server.name, server.zone_name, nic,
                                                        :access_config => access_config)
-            Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
+            Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
           end
         end
       end

data/lib/fog/{google/models/compute → compute/google/models}/addresses.rb

@@ -1,6 +1,3 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/address'
-
 module Fog
   module Compute
     class Google
@@ -9,11 +6,11 @@ module Fog
 
         def all(filters = {})
           if filters[:region]
-            data = service.list_addresses(filters[:region]).body['items'] || []
+            data = service.list_addresses(filters[:region]).body["items"] || []
           else
             data = []
-            service.list_aggregated_addresses.body['items'].each_value do |region|
-              data.concat(region['addresses']) if region['addresses']
+            service.list_aggregated_addresses.body["items"].each_value do |region|
+              data.concat(region["addresses"]) if region["addresses"]
             end
           end
           load(data)
@@ -28,25 +25,24 @@ module Fog
         end
 
         def get_by_ip_address(ip_address)
-          addresses = service.list_aggregated_addresses(:filter => "address eq .*#{ip_address}").body['items']
-          address = addresses.each_value.select { |region| region.key?('addresses') }
+          addresses = service.list_aggregated_addresses(:filter => "address eq .*#{ip_address}").body["items"]
+          address = addresses.each_value.select { |region| region.key?("addresses") }
 
           return nil if address.empty?
-          new(address.first['addresses'].first)
+          new(address.first["addresses"].first)
         end
 
         def get_by_name(ip_name)
-          names = service.list_aggregated_addresses(:filter => "name eq .*#{ip_name}").body['items']
-          name = names.each_value.select { |region| region.key?('addresses') }
+          names = service.list_aggregated_addresses(:filter => "name eq .*#{ip_name}").body["items"]
+          name = names.each_value.select { |region| region.key?("addresses") }
 
           return nil if name.empty?
-          new(name.first['addresses'].first)
+          new(name.first["addresses"].first)
         end
 
         def get_by_ip_address_or_name(ip_address_or_name)
-          get_by_ip_address(ip_address_or_name) or get_by_name(ip_address_or_name)
+          get_by_ip_address(ip_address_or_name) || get_by_name(ip_address_or_name)
         end
-
       end
     end
   end

data/lib/fog/{google/models/compute → compute/google/models}/backend_service.rb

@@ -1,50 +1,46 @@
-require 'fog/core/model'
-
 module Fog
   module Compute
     class Google
       class BackendService < Fog::Model
         identity :name
 
-        attribute :backends, :aliases => 'backends'
-        attribute :creation_timestamp, :aliases => 'kind'
-        attribute :description, :aliases => 'description'
-        attribute :fingerprint, :aliases => 'fingerprint'
-        attribute :health_checks, :aliases => 'healthChecks'
-        attribute :id, :aliases => 'id'
-        attribute :kind, :aliases => 'kind'
-        attribute :port, :aliases => 'port'
-        attribute :protocol, :aliases => 'protocol'
-        attribute :self_link, :aliases => 'selfLink'
-        attribute :timeout_sec, :aliases => 'timeoutSec'
+        attribute :backends, :aliases => "backends"
+        attribute :creation_timestamp, :aliases => "kind"
+        attribute :description, :aliases => "description"
+        attribute :fingerprint, :aliases => "fingerprint"
+        attribute :health_checks, :aliases => "healthChecks"
+        attribute :id, :aliases => "id"
+        attribute :kind, :aliases => "kind"
+        attribute :port, :aliases => "port"
+        attribute :protocol, :aliases => "protocol"
+        attribute :self_link, :aliases => "selfLink"
+        attribute :timeout_sec, :aliases => "timeoutSec"
 
         def save
           requires :name, :health_checks
 
           options = {
-            'description' => description,
-            'backends' => backends,
-            'fingerprint' => fingerprint,
-            'healthChecks' => health_checks,
-            'port' => port,
-            'protocol' => protocol,
-            'timeoutSec' => timeout_sec
+            "description" => description,
+            "backends" => backends,
+            "fingerprint" => fingerprint,
+            "healthChecks" => health_checks,
+            "port" => port,
+            "protocol" => protocol,
+            "timeoutSec" => timeout_sec
           }
 
           data = service.insert_backend_service(name, options).body
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data['name'])
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data["name"])
           operation.wait_for { !pending? }
           reload
         end
 
-        def destroy(async=true)
+        def destroy(async = true)
           requires :name
 
           data = service.delete_backend_service(name)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'])
-          unless async
-            operation.wait_for { ready? }
-          end
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"])
+          operation.wait_for { ready? } unless async
           operation
         end
 
@@ -52,21 +48,19 @@ module Fog
           service.get_backend_service_health self
         end
 
-        def add_backend backend
+        def add_backend(backend)
           # ensure backend is an array of hashes
           backend = [backend] unless backend.class == Array
-          backend.map! { |resource| resource.class == String ? { 'group' => resource }: resource }
+          backend.map! { |resource| resource.class == String ? { "group" => resource } : resource }
           service.add_backend_service_backends(self, backend)
           reload
         end
 
         def ready?
-          begin
-            service.get_backend_service(self.name)
-            true
-          rescue Fog::Errors::NotFound
-            false
-          end
+          service.get_backend_service(name)
+          true
+        rescue Fog::Errors::NotFound
+          false
         end
 
         def reload

data/lib/fog/{google/models/compute → compute/google/models}/backend_services.rb

@@ -1,14 +1,11 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/backend_service'
-
 module Fog
   module Compute
     class Google
       class BackendServices < Fog::Collection
         model Fog::Compute::Google::BackendService
 
-        def all(filters={})
-          data = service.list_backend_services.body['items'] || []
+        def all(_filters = {})
+          data = service.list_backend_services.body["items"] || []
           load(data)
         end
 

data/lib/fog/{google/models/compute → compute/google/models}/disk.rb

@@ -1,5 +1,3 @@
-require 'fog/core/model'
-
 module Fog
   module Compute
     class Google
@@ -8,16 +6,16 @@ module Fog
 
         attribute :kind
         attribute :id
-        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
         attribute :zone, :aliases => :zone_name
         attribute :status
         attribute :description
-        attribute :size_gb, :aliases => 'sizeGb'
-        attribute :self_link, :aliases => 'selfLink'
-        attribute :source_image, :aliases => 'sourceImage'
-        attribute :source_image_id, :aliases => 'sourceImageId'
-        attribute :source_snapshot, :aliases => 'sourceSnapshot'
-        attribute :source_snapshot_id, :aliases => 'sourceSnapshotId'
+        attribute :size_gb, :aliases => "sizeGb"
+        attribute :self_link, :aliases => "selfLink"
+        attribute :source_image, :aliases => "sourceImage"
+        attribute :source_image_id, :aliases => "sourceImageId"
+        attribute :source_snapshot, :aliases => "sourceSnapshot"
+        attribute :source_snapshot_id, :aliases => "sourceSnapshotId"
         attribute :type
 
         def save
@@ -25,60 +23,58 @@ module Fog
 
           options = {}
           my_description = "Created with fog"
-          if !source_image.nil?
+          unless source_image.nil?
             my_description = "Created from image: #{source_image}"
           end
           if source_image.nil? && !source_snapshot.nil?
-            options['sourceSnapshot'] = source_snapshot
+            options["sourceSnapshot"] = source_snapshot
             my_description = "Created from snapshot: #{source_snapshot}"
           end
 
-          options['sizeGb'] = size_gb
-          options['description'] = description || my_description
-          options['type'] = type
+          options["sizeGb"] = size_gb
+          options["description"] = description || my_description
+          options["type"] = type
 
           data = service.insert_disk(name, zone, source_image, options)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
           operation.wait_for { !pending? }
           reload
         end
 
-        def destroy(async=true)
+        def destroy(async = true)
           requires :name, :zone
 
           data = service.delete_disk(name, zone_name)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
-          unless async
-            operation.wait_for { ready? }
-          end
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
+          operation.wait_for { ready? } unless async
           operation
         end
 
         def zone_name
-          zone.nil? ? nil : zone.split('/')[-1]
+          zone.nil? ? nil : zone.split("/")[-1]
         end
 
         # auto_delete can only be applied to disks created before instance creation.
         # auto_delete = true will automatically delete disk upon instance termination.
-        def get_object(writable=true, boot=false, device_name=nil, auto_delete=false)
-          mode = writable ? 'READ_WRITE' : 'READ_ONLY'
+        def get_object(writable = true, boot = false, device_name = nil, auto_delete = false)
+          mode = writable ? "READ_WRITE" : "READ_ONLY"
           value = {
-            'autoDelete' => auto_delete,
-            'boot' => boot,
-            'source' => self_link,
-            'mode' => mode,
-            'deviceName' => device_name,
-            'type' => 'PERSISTENT'
-          }.select { |k, v| !v.nil? }
-          return Hash[value]
+            "autoDelete" => auto_delete,
+            "boot" => boot,
+            "source" => self_link,
+            "mode" => mode,
+            "deviceName" => device_name,
+            "type" => "PERSISTENT"
+          }.select { |_k, v| !v.nil? }
+          Hash[value]
         end
 
-        def get_as_boot_disk(writable=true, auto_delete=false)
+        def get_as_boot_disk(writable = true, auto_delete = false)
           get_object(writable, true, nil, auto_delete)
         end
 
         def ready?
-          self.status == RUNNING_STATE
+          status == RUNNING_STATE
         end
 
         def reload
@@ -95,20 +91,20 @@ module Fog
           self
         end
 
-        def create_snapshot(snapshot_name, snapshot_description="")
+        def create_snapshot(snapshot_name, snapshot_description = "")
           requires :name, :zone
 
-          if snapshot_name.nil? or snapshot_name.empty?
-            raise ArgumentError, 'Invalid snapshot name'
+          if snapshot_name.nil? || snapshot_name.empty?
+            raise ArgumentError, "Invalid snapshot name"
           end
 
           options = {
-            'name'        => snapshot_name,
-            'description' => snapshot_description,
+            "name"        => snapshot_name,
+            "description" => snapshot_description
           }
 
           data = service.insert_snapshot(name, zone_name, service.project, options)
-          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body['name'], data.body['zone'])
+          operation = Fog::Compute::Google::Operations.new(:service => service).get(data.body["name"], data.body["zone"])
           operation.wait_for { !pending? }
           service.snapshots.get(snapshot_name)
         end

data/lib/fog/{google/models/compute → compute/google/models}/disk_type.rb

@@ -1,5 +1,3 @@
-require 'fog/core/model'
-
 module Fog
   module Compute
     class Google
@@ -8,17 +6,17 @@ module Fog
 
         attribute :kind
         attribute :id
-        attribute :creation_timestamp, :aliases => 'creationTimestamp'
+        attribute :creation_timestamp, :aliases => "creationTimestamp"
         attribute :deprecated
         attribute :description
-        attribute :self_link, :aliases => 'selfLink'
-        attribute :valid_disk_size, :aliases => 'validDiskSize'
+        attribute :self_link, :aliases => "selfLink"
+        attribute :valid_disk_size, :aliases => "validDiskSize"
         attribute :zone
 
         def reload
           requires :identity, :zone
 
-          data = collection.get(identity, self.zone)
+          data = collection.get(identity, zone)
           merge_attributes(data.attributes)
           self
         end

data/lib/fog/{google/models/compute → compute/google/models}/disk_types.rb

@@ -1,6 +1,3 @@
-require 'fog/core/collection'
-require 'fog/google/models/compute/disk_type'
-
 module Fog
   module Compute
     class Google
@@ -8,12 +5,12 @@ module Fog
         model Fog::Compute::Google::DiskType
 
         def all(filters = {})
-          if filters['zone']
-            data = service.list_disk_types(filters['zone']).body['items'] || []
+          if filters["zone"]
+            data = service.list_disk_types(filters["zone"]).body["items"] || []
           else
             data = []
-            service.list_aggregated_disk_types.body['items'].each_value do |zone|
-              data.concat(zone['diskTypes']) if zone['diskTypes']
+            service.list_aggregated_disk_types.body["items"].each_value do |zone|
+              data.concat(zone["diskTypes"]) if zone["diskTypes"]
             end
           end
           load(data)
@@ -24,10 +21,10 @@ module Fog
           if zone
             response = service.get_disk_type(identity, zone).body
           else
-            disk_types = service.list_aggregated_disk_types(:filter => "name eq .*#{identity}").body['items'] || {}
-            disk_type = disk_types.each_value.detect { |zone| zone.key?('diskTypes') } || {}
+            disk_types = service.list_aggregated_disk_types(:filter => "name eq .*#{identity}").body["items"] || {}
+            disk_type = disk_types.each_value.detect { |zone| zone.key?("diskTypes") } || {}
 
-            response = disk_type['diskTypes'].first unless disk_type.empty?
+            response = disk_type["diskTypes"].first unless disk_type.empty?
           end
           return nil if response.nil?
           new(response)