hcloud 0.1.1 → 0.1.2

data/lib/hcloud/client.rb

@@ -1,5 +1,5 @@
-autoload :Typhoeus, "typhoeus"
-autoload :Oj, "oj"
+autoload :Typhoeus, 'typhoeus'
+autoload :Oj, 'oj'
 
 module Hcloud
   class Client
@@ -14,7 +14,7 @@ module Hcloud
     end
 
     def authorized?
-      request("server_types").run
+      request('server_types').run
       true
     rescue Error::Unauthorized
       false
@@ -68,14 +68,14 @@ module Hcloud
         q << x.to_param
       end
       path = path.dup
-      path << "?"+q.join("&")
+      path << '?' + q.join('&')
       r = Typhoeus::Request.new(
         "https://api.hetzner.cloud/v1/#{path}",
         {
-          headers: { 
-            "Authorization" => "Bearer #{token}",
-            "Content-Type" => "application/json",
-          },
+          headers: {
+            'Authorization' => "Bearer #{token}",
+            'Content-Type' => 'application/json'
+          }
         }.merge(options)
       )
       r.on_complete do |response|
@@ -88,20 +88,20 @@ module Hcloud
           raise Error::ServerError, "Connection error: #{response.return_code}"
         when 400...600
           j = Oj.load(response.body)
-          code = j.dig("error", "code")
+          code = j.dig('error', 'code')
           error_class = case code
-                        when "invalid_input" then Error::InvalidInput
-                        when "forbidden" then Error::Forbidden
-                        when "locked" then Error::Locked
-                        when "not_found" then Error::NotFound
-                        when "rate_limit_exceeded" then Error::RateLimitExceeded
-                        when "resource_unavailable" then Error::ResourceUnavilable
-                        when "service_error" then Error::ServiceError
-                        when "uniqueness_error" then Error::UniquenessError
+                        when 'invalid_input' then Error::InvalidInput
+                        when 'forbidden' then Error::Forbidden
+                        when 'locked' then Error::Locked
+                        when 'not_found' then Error::NotFound
+                        when 'rate_limit_exceeded' then Error::RateLimitExceeded
+                        when 'resource_unavailable' then Error::ResourceUnavilable
+                        when 'service_error' then Error::ServiceError
+                        when 'uniqueness_error' then Error::UniquenessError
                         else
                           Error::ServerError
                         end
-          raise error_class, j.dig("error", "message")
+          raise error_class, j.dig('error', 'message')
         end
       end
       r

data/lib/hcloud/datacenter.rb

@@ -5,10 +5,9 @@ module Hcloud
       name: nil,
       description: nil,
       location: Location,
-      server_types: nil,
-    }
+      server_types: nil
+    }.freeze
 
     include EntryLoader
-
   end
 end

data/lib/hcloud/datacenter_resource.rb

@@ -3,10 +3,10 @@ module Hcloud
     include Enumerable
 
     def all
-      j = Oj.load(request("datacenters").run.body)
-      dc = j["datacenters"].map{|x| Datacenter.new(x, self, client) }
-      dc.reject{|x| x.id == j["recommendation"]}.unshift(
-        dc.find{|x| x.id == j["recommendation"]}
+      j = Oj.load(request('datacenters').run.body)
+      dc = j['datacenters'].map { |x| Datacenter.new(x, self, client) }
+      dc.reject { |x| x.id == j['recommendation'] }.unshift(
+        dc.find { |x| x.id == j['recommendation'] }
       )
     end
 
@@ -16,32 +16,30 @@ module Hcloud
 
     def find(id)
       Datacenter.new(
-        Oj.load(request("datacenters/#{id}").run.body)["datacenter"],
+        Oj.load(request("datacenters/#{id}").run.body)['datacenter'],
         self,
         client
       )
     end
-    
+
     def find_by(name:)
-      x = Oj.load(request("datacenters", q: {name: name}).run.body)["datacenters"]
+      x = Oj.load(request('datacenters', q: { name: name }).run.body)['datacenters']
       return nil if x.none?
       x.each do |s|
         return Datacenter.new(s, self, client)
       end
     end
-    
+
     def [](arg)
       case arg
       when Integer
-       begin
-         find(arg)
-       rescue Error::NotFound
-       end
+        begin
+          find(arg)
+        rescue Error::NotFound
+        end
       when String
         find_by(name: arg)
       end
     end
-
   end
 end
-

data/lib/hcloud/entry_loader.rb

@@ -5,7 +5,7 @@ module Hcloud
 
     included do |klass|
       klass.send(:attr_reader, :parent, :client)
-      klass.const_get(:Attributes).each do |attribute, value|
+      klass.const_get(:Attributes).each do |attribute, _value|
         klass.send(:attr_accessor, attribute)
       end
     end
@@ -16,14 +16,14 @@ module Hcloud
       self.class.const_get(:Attributes).each do |attribute, value|
         case value
         when nil
-          self.send("#{attribute}=", resource[attribute.to_s])
+          send("#{attribute}=", resource[attribute.to_s])
         when :time
           unless resource[attribute.to_s].nil?
-            self.send("#{attribute}=", Time.parse(resource[attribute.to_s]))
+            send("#{attribute}=", Time.parse(resource[attribute.to_s]))
           end
-        else 
-          if value.is_a?(Class) and value.include?(EntryLoader)
-            self.send("#{attribute}=", value.new(resource[attribute.to_s], self, client))
+        else
+          if value.is_a?(Class) && value.include?(EntryLoader)
+            send("#{attribute}=", value.new(resource[attribute.to_s], self, client))
           end
         end
       end

data/lib/hcloud/floating_ip.rb

@@ -8,29 +8,29 @@ module Hcloud
       dns_ptr: nil,
       server: nil,
       home_location: Location,
-      blocked: nil,
-    }
+      blocked: nil
+    }.freeze
     include EntryLoader
 
     def update(description:)
-      j = Oj.load(request("floating_ips/#{id.to_i}", 
-                          j: {description: description}, 
+      j = Oj.load(request("floating_ips/#{id.to_i}",
+                          j: { description: description },
                           method: :put).run.body)
-      FloatingIP.new(j["floating_ip"], self, client)
+      FloatingIP.new(j['floating_ip'], self, client)
     end
-    
+
     def assign(server:)
-      j = Oj.load(request("floating_ips/#{id.to_i}/actions/assign", 
-                          j: {server: server}).run.body)
-      Action.new(j["action"], self, client)
+      j = Oj.load(request("floating_ips/#{id.to_i}/actions/assign",
+                          j: { server: server }).run.body)
+      Action.new(j['action'], self, client)
     end
-    
+
     def unassign
-      j = Oj.load(request("floating_ips/#{id.to_i}/actions/unassign", 
+      j = Oj.load(request("floating_ips/#{id.to_i}/actions/unassign",
                           method: :post).run.body)
-      Action.new(j["action"], self, client)
+      Action.new(j['action'], self, client)
     end
-   
+
     def actions
       ActionResource.new(client: client, parent: self, base_path: "floating_ips/#{id.to_i}")
     end
@@ -39,6 +39,5 @@ module Hcloud
       request("floating_ips/#{id}", method: :delete).run.body
       true
     end
-
   end
 end

data/lib/hcloud/floating_ip_resource.rb

@@ -3,25 +3,26 @@ module Hcloud
     include Enumerable
 
     def all
-      j = Oj.load(request("floating_ips").run.body)
-      j["floating_ips"].map{|x| FloatingIP.new(x, self, client) }
+      mj('floating_ips') do |j|
+        j.flat_map { |x| x['floating_ips'].map { |x| FloatingIP.new(x, self, client) } }
+      end
     end
 
     def create(type:, server: nil, home_location: nil, description: nil)
       query = {}
-      method(:create).parameters.inject(query) do |r,x| 
+      method(:create).parameters.inject(query) do |r, x|
         (var = eval(x.last.to_s)).nil? ? r : r.merge!(x.last => var)
       end
-      j = Oj.load(request("floating_ips", j: query, code: 200).run.body)
+      j = Oj.load(request('floating_ips', j: query, code: 200).run.body)
       [
-        j.key?("action") ? Action.new(j["action"], self, client) : nil,
-        FloatingIP.new(j["floating_ip"], self, client),
+        j.key?('action') ? Action.new(j['action'], self, client) : nil,
+        FloatingIP.new(j['floating_ip'], self, client)
       ]
     end
 
     def find(id)
       FloatingIP.new(
-        Oj.load(request("floating_ips/#{id}").run.body)["floating_ip"],
+        Oj.load(request("floating_ips/#{id}").run.body)['floating_ip'],
         self,
         client
       )
@@ -30,12 +31,11 @@ module Hcloud
     def [](arg)
       case arg
       when Integer
-       begin
-         find(arg)
-       rescue Error::NotFound
-       end
+        begin
+          find(arg)
+        rescue Error::NotFound
+        end
       end
     end
-
   end
 end

data/lib/hcloud/image.rb

@@ -13,22 +13,22 @@ module Hcloud
       bound_to: nil,
       os_flavor: nil,
       os_version: nil,
-      rapid_deploy: nil,
-    }
+      rapid_deploy: nil
+    }.freeze
 
     include EntryLoader
 
     def to_snapshot
-      update(type: "snapshot")
+      update(type: 'snapshot')
     end
 
     def update(description: nil, type: nil)
       query = {}
-      method(:update).parameters.inject(query) do |r,x| 
+      method(:update).parameters.inject(query) do |r, x|
         (var = eval(x.last.to_s)).nil? ? r : r.merge!(x.last => var)
       end
       Image.new(
-        Oj.load(request("images/#{id.to_i}", j: query, method: :put).run.body)["image"],
+        Oj.load(request("images/#{id.to_i}", j: query, method: :put).run.body)['image'],
         parent,
         client
       )

data/lib/hcloud/image_resource.rb

@@ -1,11 +1,11 @@
 module Hcloud
   class ImageResource < AbstractResource
     def all
-      mj("images") do |j|
-        j.flat_map{|x| x["images"].map{ |x| Image.new(x, self, client) } }
+      mj('images') do |j|
+        j.flat_map { |x| x['images'].map { |x| Image.new(x, self, client) } }
       end
     end
-    
+
     def [](arg)
       case arg
       when Integer
@@ -20,29 +20,28 @@ module Hcloud
 
     def find(id)
       Image.new(
-        Oj.load(request("images/#{id.to_i}").run.body)["image"],
+        Oj.load(request("images/#{id.to_i}").run.body)['image'],
         self,
         client
       )
     end
-    
+
     def where(sort: nil, type: nil, bound_to: nil, name: nil)
       query = {}
-      method(:where).parameters.inject(query) do |r,x| 
+      method(:where).parameters.inject(query) do |r, x|
         (var = eval(x.last.to_s)).nil? ? r : r.merge!(x.last => var)
       end
-      mj("images", q: query) do |j|
-        j.flat_map{|x| x["images"].map{ |x| Image.new(x, self, client) } }
+      mj('images', q: query) do |j|
+        j.flat_map { |x| x['images'].map { |x| Image.new(x, self, client) } }
       end
     end
 
     def find_by(name:)
-      j = Oj.load(request("images", q: {name: name}).run.body)["images"]
+      j = Oj.load(request('images', q: { name: name }).run.body)['images']
       return if j.none?
       j.each do |x|
         return Image.new(x, self, client)
       end
     end
-
   end
 end

data/lib/hcloud/iso.rb

@@ -5,8 +5,8 @@ module Hcloud
       name: nil,
       description: nil,
       type: nil
-    }
-    
+    }.freeze
+
     include EntryLoader
   end
 end

data/lib/hcloud/iso_resource.rb

@@ -1,8 +1,8 @@
 module Hcloud
   class IsoResource < AbstractResource
     def all
-      mj("isos") do |j|
-        j.flat_map{|x| x["isos"].map{ |x| Iso.new(x, self, client) } }
+      mj('isos') do |j|
+        j.flat_map { |x| x['isos'].map { |x| Iso.new(x, self, client) } }
       end
     end
 
@@ -20,19 +20,18 @@ module Hcloud
 
     def find(id)
       Iso.new(
-        Oj.load(request("isos/#{id.to_i}").run.body)["iso"],
+        Oj.load(request("isos/#{id.to_i}").run.body)['iso'],
         self,
         client
       )
     end
 
     def find_by(name:)
-      j = Oj.load(request("isos", q: {name: name}).run.body)["isos"]
+      j = Oj.load(request('isos', q: { name: name }).run.body)['isos']
       return if j.none?
       j.each do |x|
         return Iso.new(x, self, client)
       end
     end
-
   end
 end

data/lib/hcloud/location.rb

@@ -7,10 +7,9 @@ module Hcloud
       country: nil,
       city: nil,
       longitude: nil,
-      latitude: nil,
-    }
+      latitude: nil
+    }.freeze
 
     include EntryLoader
-
   end
 end

data/lib/hcloud/location_resource.rb

@@ -1,38 +1,37 @@
 module Hcloud
   class LocationResource < AbstractResource
     def all
-      mj("locations") do |j|
-        j.flat_map{|x| x["locations"].map{ |x| Location.new(x, self, client) } }
+      mj('locations') do |j|
+        j.flat_map { |x| x['locations'].map { |x| Location.new(x, self, client) } }
       end
     end
 
     def find(id)
       Location.new(
-        Oj.load(request("locations/#{id}").run.body)["location"],
+        Oj.load(request("locations/#{id}").run.body)['location'],
         self,
         client
       )
     end
-    
+
     def find_by(name:)
-      x = Oj.load(request("locations", q: {name: name}).run.body)["locations"]
+      x = Oj.load(request('locations', q: { name: name }).run.body)['locations']
       return nil if x.none?
       x.each do |s|
         return Location.new(s, self, client)
       end
     end
-    
+
     def [](arg)
       case arg
       when Integer
-       begin
-         find(arg)
-       rescue Error::NotFound
-       end
+        begin
+          find(arg)
+        rescue Error::NotFound
+        end
       when String
         find_by(name: arg)
       end
     end
-
   end
 end