hcloud 0.1.2 → 1.0.0

data/lib/hcloud/datacenter.rb

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 module Hcloud
   class Datacenter
-    Attributes = {
-      id: nil,
-      name: nil,
-      description: nil,
-      location: Location,
-      server_types: nil
-    }.freeze
+    require 'hcloud/datacenter_resource'
 
     include EntryLoader
+
+    schema(
+      location: Location
+    )
   end
 end

data/lib/hcloud/datacenter_resource.rb

@@ -1,44 +1,19 @@
+# frozen_string_literal: true
+
 module Hcloud
   class DatacenterResource < AbstractResource
-    include Enumerable
+    filter_attributes :name
 
-    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'] }
-      )
-    end
+    bind_to Datacenter
 
     def recommended
       all.first
     end
 
-    def find(id)
-      Datacenter.new(
-        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']
-      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
-      when String
-        find_by(name: arg)
+      when Integer then find_by(id: arg)
+      when String then find_by(name: arg)
       end
     end
   end

data/lib/hcloud/entry_loader.rb

@@ -1,36 +1,197 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
+require 'active_model'
+
 module Hcloud
-  module EntryLoader
+  module EntryLoader # rubocop:disable Metrics/ModuleLength
     extend ActiveSupport::Concern
 
+    module Collection
+      attr_accessor :response
+    end
+
     included do |klass|
-      klass.send(:attr_reader, :parent, :client)
-      klass.const_get(:Attributes).each do |attribute, _value|
-        klass.send(:attr_accessor, attribute)
-      end
+      klass.send(:attr_writer, :client)
+      klass.include(ActiveModel::Dirty)
     end
 
-    def initialize(resource, parent, client)
-      @parent = parent
-      @client = client
-      self.class.const_get(:Attributes).each do |attribute, value|
-        case value
-        when nil
-          send("#{attribute}=", resource[attribute.to_s])
-        when :time
-          unless resource[attribute.to_s].nil?
-            send("#{attribute}=", Time.parse(resource[attribute.to_s]))
+    class_methods do # rubocop:disable Metrics/BlockLength
+      attr_accessor :resource_url
+
+      def _callbacks
+        @_callbacks ||= { before: [], after: [] }
+      end
+
+      %i[before after].each do |method|
+        define_method(method) { |&block| _callbacks[method] << block }
+      end
+
+      def schema(**kwargs)
+        @schema ||= {}.with_indifferent_access
+        return @schema if kwargs.empty?
+
+        @schema.merge!(kwargs)
+      end
+
+      def updatable(*args)
+        define_attribute_methods(*args)
+        args.each do |updateable_attribute|
+          define_method(updateable_attribute) { _attributes[updateable_attribute] }
+          define_method("#{updateable_attribute}=") do |value|
+            if _attributes[updateable_attribute] != value
+              public_send("#{updateable_attribute}_will_change!")
+            end
+            _update_attribute(updateable_attribute, value)
           end
-        else
-          if value.is_a?(Class) && value.include?(EntryLoader)
-            send("#{attribute}=", value.new(resource[attribute.to_s], self, client))
+        end
+      end
+
+      def destructible
+        define_method(:destroy) { prepare_request(method: :delete) }
+      end
+
+      def protectable(*args)
+        define_method(:change_protection) do |**kwargs|
+          kwargs.keys.each do |key|
+            next if args.map(&:to_s).include? key.to_s
+
+            raise ArgumentError, "#{key} not an allowed protection mode (allowed: #{args})"
           end
+          prepare_request('actions/change_protection', j: kwargs)
+        end
+      end
+
+      def has_actions # rubocop:disable Naming/PredicateName
+        define_method(:actions) do
+          ActionResource.new(client: client, base_path: resource_url)
+        end
+      end
+
+      def resource_class
+        ancestors.reverse.find { |const| const.include?(Hcloud::EntryLoader) }
+      end
+
+      def from_response(response, autoload_action: nil)
+        attributes = response.resource_attributes
+        action = response.parsed_json[:action] if autoload_action
+        client = response.context.client
+        if attributes.is_a?(Array)
+          results = attributes.map { |item| new(item).tap { |entity| entity.response = response } }
+          results.tap { |ary| ary.extend(Collection) }.response = response
+          return results
+        end
+
+        return Action.new(client, action) if attributes.nil? && action
+        return new(attributes).tap { |entity| entity.response = response } if action.nil?
+
+        [
+          Action.new(client, action),
+          new(attributes).tap { |entity| entity.response = response }
+        ]
+      end
+    end
+
+    attr_accessor :response
+
+    def initialize(client = nil, **kwargs)
+      @client = client
+      _load(kwargs)
+    end
+
+    def inspect
+      "#<#{self.class.name}:0x#{__id__.to_s(16)} #{_attributes.inspect}>"
+    end
+
+    def client
+      @client || response&.context&.client
+    end
+
+    def resource_url
+      if block = self.class.resource_url
+        return instance_exec(&block)
+      end
+
+      [self.class.resource_class.name.demodulize.tableize, id].compact.join('/')
+    end
+
+    def resource_path
+      self.class.resource_class.name.demodulize.underscore
+    end
+
+    def prepare_request(url_suffix = nil, **kwargs, &block)
+      kwargs[:resource_path] ||= resource_path
+      kwargs[:resource_class] ||= self.class
+      kwargs[:autoload_action] = true unless kwargs.key?(:autoload_action)
+
+      client.prepare_request(
+        [resource_url, url_suffix].compact.join('/'),
+        **kwargs,
+        &block
+      )
+    end
+
+    def _attributes
+      @_attributes ||= {}.with_indifferent_access
+    end
+
+    def method_missing(method, *args, &block)
+      _attributes.key?(method) ? _attributes[method] : super
+    end
+
+    def respond_to_missing?(method, *args, &block)
+      _attributes.key?(method) || super
+    end
+
+    def update(**kwargs)
+      context = self
+      _run_callbacks(:before)
+      prepare_request(j: kwargs, method: :put) do |response|
+        response.resource_class.from_response(
+          response,
+          autoload_action: response.autoload_action
+        ).tap do |*_args|
+          _run_callbacks(:after)
+          context.send(:changes_applied)
         end
       end
     end
 
-    def request(*args)
-      client.request(*args)
+    def save
+      update(changes.map { |key, _value| [key.to_sym, _attributes[key]] }.to_h)
+    end
+
+    def rollback
+      restore_attributes
+    end
+
+    def _run_callbacks(order)
+      self.class._callbacks[order].each { |block| instance_exec(&block) }
+    end
+
+    def _update_attribute(key, value)
+      _attributes[key] = value
+      instance_variable_set("@#{key}", value)
+    end
+
+    def _load(resource)
+      @_attributes = {}.with_indifferent_access
+
+      resource.each do |key, value|
+        definition = self.class.schema[key]
+
+        if definition == :time
+          _update_attribute(key, value ? Time.parse(value) : nil)
+          next
+        end
+
+        if definition.is_a?(Class) && definition.include?(EntryLoader)
+          _update_attribute(key, value ? definition.new(client, value) : nil)
+          next
+        end
+
+        _update_attribute(key, value.is_a?(Hash) ? value.with_indifferent_access : value)
+      end
     end
   end
 end

data/lib/hcloud/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hcloud
   class Error < StandardError
     class Unauthorized < Error; end

data/lib/hcloud/floating_ip.rb

@@ -1,43 +1,32 @@
+# frozen_string_literal: true
+
 module Hcloud
   class FloatingIP
-    Attributes = {
-      id: nil,
-      description: nil,
-      ip: nil,
-      type: nil,
-      dns_ptr: nil,
-      server: nil,
-      home_location: Location,
-      blocked: nil
-    }.freeze
+    require 'hcloud/floating_ip_resource'
+
     include EntryLoader
 
-    def update(description:)
-      j = Oj.load(request("floating_ips/#{id.to_i}",
-                          j: { description: description },
-                          method: :put).run.body)
-      FloatingIP.new(j['floating_ip'], self, client)
-    end
+    schema(
+      home_location: Location,
+      created: :time
+    )
+
+    protectable :delete
+    updatable :description
+    destructible
+
+    has_actions
 
     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)
+      prepare_request('actions/assign', j: COLLECT_ARGS.call(__method__, binding))
     end
 
     def unassign
-      j = Oj.load(request("floating_ips/#{id.to_i}/actions/unassign",
-                          method: :post).run.body)
-      Action.new(j['action'], self, client)
-    end
-
-    def actions
-      ActionResource.new(client: client, parent: self, base_path: "floating_ips/#{id.to_i}")
+      prepare_request('actions/unassign', method: :post)
     end
 
-    def destroy
-      request("floating_ips/#{id}", method: :delete).run.body
-      true
+    def change_dns_ptr(ip:, dns_ptr:)
+      prepare_request('actions/change_dns_ptr', j: COLLECT_ARGS.call(__method__, binding))
     end
   end
 end

data/lib/hcloud/floating_ip_resource.rb

@@ -1,40 +1,25 @@
+# frozen_string_literal: true
+
 module Hcloud
   class FloatingIPResource < AbstractResource
-    include Enumerable
+    filter_attributes :name
 
-    def all
-      mj('floating_ips') do |j|
-        j.flat_map { |x| x['floating_ips'].map { |x| FloatingIP.new(x, self, client) } }
-      end
-    end
+    bind_to FloatingIP
 
-    def create(type:, server: nil, home_location: nil, description: nil)
-      query = {}
-      method(:create).parameters.inject(query) do |r, x|
-        (var = eval(x.last.to_s)).nil? ? r : r.merge!(x.last => var)
+    def [](arg)
+      case arg
+      when Integer then find_by(id: arg)
+      when String then find_by(name: arg)
       end
-      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)
-      ]
     end
 
-    def find(id)
-      FloatingIP.new(
-        Oj.load(request("floating_ips/#{id}").run.body)['floating_ip'],
-        self,
-        client
-      )
-    end
-
-    def [](arg)
-      case arg
-      when Integer
-        begin
-          find(arg)
-        rescue Error::NotFound
-        end
+    def create(type:, server: nil, home_location: nil, description: nil)
+      prepare_request(
+        'floating_ips', j: COLLECT_ARGS.call(__method__, binding),
+                        expected_code: 201
+      ) do |response|
+        action = Action.new(client, response[:action]) if response[:action]
+        [action, FloatingIP.new(client, response[:floating_ip])]
       end
     end
   end

data/lib/hcloud/image.rb

@@ -1,42 +1,22 @@
+# frozen_string_literal: true
+
 module Hcloud
   class Image
-    Attributes = {
-      id: nil,
-      type: nil,
-      status: nil,
-      name: nil,
-      description: nil,
-      image_size: nil,
-      disk_size: nil,
-      created: :time,
-      created_from: nil,
-      bound_to: nil,
-      os_flavor: nil,
-      os_version: nil,
-      rapid_deploy: nil
-    }.freeze
+    require 'hcloud/image_resource'
 
     include EntryLoader
 
-    def to_snapshot
-      update(type: 'snapshot')
-    end
+    schema(
+      created: :time,
+      deprecated: :time
+    )
 
-    def update(description: nil, type: nil)
-      query = {}
-      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'],
-        parent,
-        client
-      )
-    end
+    protectable :delete
+    updatable :description, :type
+    destructible
 
-    def destroy
-      request("images/#{id.to_i}", method: :delete).run
-      true
+    def to_snapshot
+      update(type: 'snapshot')
     end
   end
 end