kozo 0.2.0 → 0.3.0

data/lib/kozo/operations/show.rb

@@ -7,6 +7,23 @@ module Kozo
       self.display_symbol = nil
 
       def apply(state); end
+
+      def to_s
+        l = resource.attribute_names.map(&:length).max || 1
+
+        attrs = resource
+          .attributes
+          .map { |k, v| "  r.#{k.to_s.ljust(l)} = #{v.as_s.indent(2)[2..]}" }
+          .join("\n")
+
+        <<~DSL.chomp
+          #{"# #{resource.address}:".bold}
+          resource "#{resource.resource_name}", "#{resource.state_name}" do |r|
+          #{attrs}
+          end
+
+        DSL
+      end
     end
   end
 end

data/lib/kozo/operations/update.rb

@@ -14,6 +14,23 @@ module Kozo
         state.resources.delete(resource)
         state.resources << resource
       end
+
+      def to_s
+        l = resource.attribute_names.map(&:length).max || 1
+
+        attrs = resource
+          .attributes
+          .map { |k, v| "  #{resource.changes.key?(k) ? display_symbol : ' '} r.#{k.to_s.ljust(l)} = #{resource.changes.key?(k) ? "#{resource.changes[k].first.as_s.indent(4)[4..]} -> #{v.as_s.indent(4)[4..]}" : v.as_s.indent(4)[4..]}" }
+          .join("\n")
+
+        <<~DSL.chomp
+          #{"# #{resource.address}:".bold}
+          #{display_symbol} resource "#{resource.resource_name}", "#{resource.state_name}" do |r|
+          #{attrs}
+          end
+
+        DSL
+      end
     end
   end
 end

data/lib/kozo/options.rb

@@ -28,6 +28,30 @@ module Kozo
       verbose.present?
     end
 
+    def debug=(value)
+      @debug = value.present?
+    end
+
+    def debug
+      @debug ||= false
+    end
+
+    def debug?
+      debug.present?
+    end
+
+    def dry_run=(value)
+      @dry_run = value.present?
+    end
+
+    def dry_run
+      @dry_run ||= false
+    end
+
+    def dry_run?
+      dry_run.present?
+    end
+
     def [](key)
       send(key)
     end

data/lib/kozo/providers/dummy/resources/dummy.rb

@@ -7,8 +7,19 @@ module Kozo
         class Dummy < Resource
           self.resource_name = "dummy"
 
+          self.creatable_attribute_names = [:name, :labels, :description]
+          self.updatable_attribute_names = [:name, :labels, :description]
+
           attribute :name
           attribute :description
+
+          attribute :labels, multiple: true
+
+          readonly
+
+          attribute :location
+
+          attribute :locked, type: :boolean, default: false
         end
       end
     end

data/lib/kozo/providers/hcloud/provider.rb

@@ -11,7 +11,7 @@ module Kozo
         self.provider_name = "hcloud"
 
         def setup
-          ::HCloud::Client.connection = ::HCloud::Client.new(access_token: key)
+          ::HCloud::Client.connection = ::HCloud::Client.new(access_token: key, logger: Kozo.debug_logger)
         end
 
         def ==(other)

data/lib/kozo/providers/hcloud/resource.rb

@@ -6,43 +6,66 @@ module Kozo
       class Resource < Kozo::Resource
         self.provider_name = "hcloud"
 
+        readonly
+
         attribute :id, type: :integer
 
+        readwrite
+
         protected
 
         def refresh
+          raise NotPersisted, "resource is not yet persisted" unless id
+
           resource = resource_class.find(id)
 
-          attribute_names
+          # Set local attributes from remote resource
+          readable_attribute_names
             .excluding(:id)
             .each { |attr| send(:"#{attr}=", resource.send(attr)) }
+        rescue ::HCloud::Errors::NotFound => e
+          raise StateError, "#{address}: #{e.message}"
         end
 
         def create
-          resource = resource_class.new(**attributes.except(:id))
+          resource = resource_class.new(creatable_attributes)
           resource.create
 
-          attribute_names
+          # Set local attributes from remote resource
+          readable_attribute_names
             .each { |attr| send(:"#{attr}=", resource.send(attr)) }
+        rescue ::HCloud::Errors::UniquenessError => e
+          raise ResourceError, "#{address}: #{e.message}"
         end
 
         def update
+          raise NotPersisted unless id
+
           resource = resource_class.find(id)
 
-          attribute_names
-            .excluding(:id)
+          # Set remote attributes from local resource
+          updatable_attribute_names
             .each { |attr| resource.send(:"#{attr}=", send(attr)) }
 
           resource.update
 
-          attribute_names
+          readable_attribute_names
             .excluding(:id)
             .each { |attr| send(:"#{attr}=", resource.send(attr)) }
+        rescue ::HCloud::Errors::NotFound => e
+          raise StateError, "#{address}: #{e.message}"
+        rescue ::HCloud::Errors::UniquenessError => e
+          raise ResourceError, "#{address}: #{e.message}"
         end
 
         def destroy
-          resource = resource_class.find(id)
+          # Use rid, because id will have been blanked
+          raise NotPersisted unless rid
+
+          resource = resource_class.find(rid)
           resource.delete
+        rescue ::HCloud::Errors::NotFound => e
+          raise StateError, "#{address}: #{e.message}"
         end
 
         private

data/lib/kozo/providers/hcloud/resources/server.rb

@@ -7,21 +7,29 @@ module Kozo
         class Server < Resource
           self.resource_name = "hcloud_server"
 
+          self.creatable_attribute_names = [:name, :image, :server_type, :location, :datacenter, :user_data, :ssh_keys, :labels]
+          self.updatable_attribute_names = [:name, :ssh_keys, :labels]
+
           attribute :name
-          attribute :image
-          attribute :server_type
-          attribute :location
-          attribute :datacenter
 
-          attribute :user_data
+          attribute :image, wrapped: true
+          attribute :server_type, wrapped: true
+          attribute :location, wrapped: true
+          attribute :datacenter, wrapped: true
 
           attribute :labels, type: :hash
 
-          attribute :ssh_keys, multiple: true
+          readonly
+
+          attribute :locked, type: :boolean
 
-          attribute :locked, argument: false, type: :boolean
+          attribute :created, type: :time
+
+          writeonly
+
+          attribute :user_data
 
-          attribute :created, argument: false, type: :time
+          attribute :ssh_keys, multiple: true, type: :reference
         end
       end
     end

data/lib/kozo/providers/hcloud/resources/ssh_key.rb

@@ -7,11 +7,16 @@ module Kozo
         class SSHKey < Resource
           self.resource_name = "hcloud_ssh_key"
 
+          self.creatable_attribute_names = [:name, :public_key, :labels]
+          self.updatable_attribute_names = [:name, :labels]
+
           attribute :name
           attribute :public_key
           attribute :labels, type: :hash
 
-          attribute :created, type: :time, argument: false
+          readonly
+
+          attribute :created, type: :time
         end
       end
     end

data/lib/kozo/reference.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Reference
+    attr_reader :resource_class, :state_name, :id
+
+    def initialize(resource_class: nil, id: nil)
+      @resource_class = resource_class
+      @id = id
+    end
+
+    def method_missing(method_name, *_arguments)
+      # Raise NoMethodError when `state_name` was already set (usually because of a programming error)
+      return super if @state_name
+
+      @state_name = method_name.to_s
+
+      self
+    end
+
+    def resolve(configuration)
+      raise StateError, "no state name specified" unless state_name
+
+      resource = configuration
+        .state
+        .resources
+        .find { |r| r.address == address }
+
+      raise StateError, "no such resource address: #{address}" unless resource
+
+      @id = resource.id
+    end
+
+    def respond_to_missing?(_method_name, _include_private = false)
+      true
+    end
+
+    def to_h
+      {
+        id: id,
+      }
+    end
+
+    def as_h
+      id
+    end
+
+    def as_s
+      id&.as_s || "(known after apply)"
+    end
+
+    private
+
+    def address
+      "#{resource_class.resource_name}.#{state_name}"
+    end
+  end
+end

data/lib/kozo/resource.rb

@@ -3,24 +3,36 @@
 module Kozo
   class Resource
     include Attributes
-
     include Assignment
-    include Mark
     include Track
+    include ReadWrite
 
     attr_accessor :provider, :state_name
 
+    readonly
+
     attribute :id
 
+    readwrite
+
     class_attribute :resource_name, :provider_name
 
+    class_attribute :creatable_attribute_names,
+                    :updatable_attribute_names,
+                    default: []
+
     def address
       "#{resource_name}.#{state_name}"
     end
 
+    # Catchall for id, also works when the resource will be deleted
+    def rid
+      id || id_was
+    end
+
     def ==(other)
       self.class == other.class &&
-        id == other.id &&
+        rid == other.rid &&
         state_name == other.state_name
     end
 
@@ -30,10 +42,26 @@ module Kozo
       [self.class, id].hash
     end
 
+    def to_dsl(prefix = nil)
+      l = attribute_names.map(&:length).max || 1
+
+      attribute_dsl = attributes
+        .map { |k, v| "  #{changes.key?(k) ? prefix : '  '}r.#{k.to_s.ljust(l)} = #{v.as_s.indent(4)[4..]}" }
+        .join("\n")
+
+      <<~DSL.chomp
+        #{"# #{address}:".bold}
+        #{prefix}resource "#{resource_name}", "#{state_name}" do |r|
+        #{attribute_dsl}
+        end
+
+      DSL
+    end
+
     def to_h
       {
         meta: meta,
-        data: attributes,
+        data: readable_attributes,
       }
     end
 
@@ -62,7 +90,7 @@ module Kozo
     def create!
       Kozo.logger.info "#{address}: creating resource"
 
-      create
+      create unless Kozo.options.dry_run?
 
       Kozo.logger.info "#{address}: created resource"
     end
@@ -73,7 +101,7 @@ module Kozo
     def update!
       Kozo.logger.info "#{address}: updating resource"
 
-      update
+      update unless Kozo.options.dry_run?
 
       Kozo.logger.info "#{address}: updated resource"
     end
@@ -84,7 +112,7 @@ module Kozo
     def destroy!
       Kozo.logger.info "#{address}: destroying resource"
 
-      destroy
+      destroy unless Kozo.options.dry_run?
 
       Kozo.logger.info "#{address}: destroyed resource"
     end

data/lib/kozo/state.rb

@@ -2,12 +2,19 @@
 
 module Kozo
   class State
-    VERSION = 1
+    VERSION = 2
 
-    attr_accessor :resources
+    attr_accessor :resources, :version
 
-    def initialize(resources = nil)
-      @resources = Set.new(resources)
+    def initialize(resources = [], version = VERSION, verify: true)
+      @resources = Array(resources)
+      @version = version
+
+      raise StateError, "unexpected version in state: got #{version}, expected #{State::VERSION}\nRun `#{File.basename($PROGRAM_NAME)} state upgrade` to upgrade your state file" unless compatible? || !verify
+    end
+
+    def compatible?
+      version == State::VERSION
     end
 
     def ==(other)
@@ -17,7 +24,6 @@ module Kozo
     def to_h
       {
         version: VERSION,
-        kozo_version: Kozo::VERSION,
         resources: resources.map(&:to_h),
       }
     end

data/lib/kozo/type.rb

@@ -8,8 +8,8 @@ module Kozo
       raise ArgumentError, "No such type: #{type}"
     end
 
-    def self.cast(value); end
-
-    def self.serialize(value); end
+    def self.cast(value)
+      value
+    end
   end
 end

data/lib/kozo/types/boolean.rb

@@ -21,10 +21,6 @@ module Kozo
 
         !FALSE_VALUES.include?(value)
       end
-
-      def self.serialize(value)
-        value
-      end
     end
   end
 end

data/lib/kozo/types/date.rb

@@ -11,10 +11,6 @@ module Kozo
       rescue ::Date::Error => e
         raise ArgumentError, e
       end
-
-      def self.serialize(value)
-        value&.iso8601
-      end
     end
   end
 end

data/lib/kozo/types/float.rb

@@ -8,10 +8,6 @@ module Kozo
 
         send :Float, value
       end
-
-      def self.serialize(value)
-        value
-      end
     end
   end
 end

data/lib/kozo/types/hash.rb

@@ -11,10 +11,6 @@ module Kozo
       rescue TypeError, NoMethodError => e
         raise ArgumentError, e
       end
-
-      def self.serialize(value)
-        value
-      end
     end
   end
 end

data/lib/kozo/types/integer.rb

@@ -8,10 +8,6 @@ module Kozo
 
         send :Integer, value
       end
-
-      def self.serialize(value)
-        value
-      end
     end
   end
 end

data/lib/kozo/types/reference.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Types
+    class Reference < Type
+      def self.cast(value)
+        return value if value.is_a? Kozo::Reference
+        return unless value.is_a? Resource
+
+        # TODO: infer configuration
+        Kozo::Reference
+          .new(resource_class: value.class, id: value.id)
+          .send(value.state_name)
+      end
+    end
+  end
+end

data/lib/kozo/types/string.rb

@@ -8,10 +8,6 @@ module Kozo
 
         send :String, value
       end
-
-      def self.serialize(value)
-        value
-      end
     end
   end
 end

data/lib/kozo/types/time.rb

@@ -9,10 +9,6 @@ module Kozo
 
         ::Time.parse(value)
       end
-
-      def self.serialize(value)
-        value&.iso8601
-      end
     end
   end
 end

data/lib/kozo/upgrade/1_initial.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Upgrade
+    class Initial < Kozo::Upgrade
+      def upgrade; end
+    end
+  end
+end

data/lib/kozo/upgrade/2_remove_kozo_version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Upgrade
+    class RemoveKozoVersion < Kozo::Upgrade
+      def upgrade
+        state
+      end
+    end
+  end
+end

data/lib/kozo/upgrade.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Upgrade
+    attr_reader :state
+
+    def initialize(state)
+      @state = state
+    end
+
+    def upgrade
+      raise NotImplementedError
+    end
+  end
+end

data/lib/kozo/version.rb

@@ -3,7 +3,7 @@
 module Kozo
   module Version
     MAJOR = 0
-    MINOR = 2
+    MINOR = 3
     PATCH = 0
     PRE   = nil
 

data/lib/kozo.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require "active_support/all"
-require "active_model"
 require "colorize"
 require "dinja"
 require "zeitwerk"
 
+require "kozo/inflector"
+
 require "byebug" if ENV["ENV"] == "development"
 
 module Kozo
@@ -28,8 +29,13 @@ module Kozo
       @logger ||= Logger.new
     end
 
+    def debug_logger
+      @debug_logger ||= Logger::Debug.new
+    end
+
     def setup
       @loader = Zeitwerk::Loader.for_gem
+      loader.inflector = Kozo::Inflector.new(__FILE__)
 
       # Register inflections
       instance_eval(File.read(root.join("config/inflections.rb")))