kozo 0.2.0 → 0.3.0

data/lib/kozo/commands/plan.rb

@@ -7,17 +7,26 @@ module Kozo
 
       attr_reader :operations
 
-      def initialize(*_args)
+      def initialize(configuration, *_args)
+        super(configuration)
+
         @operations = []
       end
 
       def start
-        @operations += configuration.changes.filter_map do |resource|
-          if resource.marked_for_creation?
-            Operations::Create.new(resource)
-          elsif resource.marked_for_deletion?
-            Operations::Destroy.new(resource)
+        Refresh.new(configuration).start
+
+        @operations = changes.filter_map do |resource|
+          if !resource.id?
+            if resource.id_changed?
+              # ID changed to nil (resource should be destroyed)
+              Operations::Destroy.new(resource)
+            else
+              # ID is nil (resource should be created)
+              Operations::Create.new(resource)
+            end
           elsif resource.changed?
+            # Resource should be updated
             Operations::Update.new(resource)
           end
         end
@@ -30,7 +39,7 @@ module Kozo
 
         return Kozo.logger.info "\nNo actions have to be performed." if operations.empty?
 
-        Kozo.logger.info "\nKozo will perform the following actions:"
+        Kozo.logger.info "\nKozo will perform the following actions:\n"
 
         operations.each { |o| Kozo.logger.info o.to_s }
       end

data/lib/kozo/commands/state/delete.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Commands
+    class State
+      class Delete < State
+        self.description = "Delete a resource from the state"
+
+        attr_reader :address
+
+        def initialize(configuration, *args)
+          @configuration = configuration
+          @address = args.shift
+
+          raise UsageError, "address not specified" unless address
+        end
+
+        def start
+          resource = state
+            .resources
+            .find { |r| r.address == address }
+
+          raise StateError, "no such resource address: #{address}" unless resource
+
+          state
+            .resources
+            .delete_if { |r| r.address == address }
+
+          Kozo.logger.info resource.address
+
+          # Write state
+          configuration
+            .backend
+            .state = state
+        end
+      end
+    end
+  end
+end

data/lib/kozo/commands/state/list.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Commands
+    class State
+      class List < State
+        self.description = "List resources in the state"
+
+        def initialize(configuration, *_args)
+          @configuration = configuration
+        end
+
+        def start
+          state
+            .resources
+            .each { |r| Kozo.logger.info r.address }
+        end
+      end
+    end
+  end
+end

data/lib/kozo/commands/state/show.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Commands
+    class State
+      class Show < State
+        self.description = "Show a resource in the state"
+
+        attr_reader :address
+
+        def initialize(configuration, *args)
+          @configuration = configuration
+          @address = args.shift
+
+          raise UsageError, "address not specified" unless address
+        end
+
+        def start
+          resource = state
+            .resources
+            .find { |r| r.address == address }
+
+          raise StateError, "no such resource address: #{address}" unless resource
+
+          Kozo.logger.info Operations::Show.new(resource).to_s
+        end
+      end
+    end
+  end
+end

data/lib/kozo/commands/state/upgrade.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Kozo
+  module Commands
+    class State
+      class Upgrade < State
+        self.description = "Upgrade the state file to the latest version"
+
+        def initialize(configuration, *_args)
+          @configuration = configuration
+        end
+
+        def start
+          return Kozo.logger.info "State file already up to date." if state.compatible?
+
+          ((state.version + 1)..Kozo::State::VERSION).each do |version|
+            file = Dir[Kozo.root.join("lib/kozo/upgrade/#{version}_*")].first
+
+            raise NotImplementedError, "upgrade file to version #{version} not found" unless file
+
+            Kozo.logger.info "Upgrading state file to version #{version}"
+
+            klass = File
+              .basename(file, ".rb")
+              .delete_prefix("#{version}_")
+              .prepend("kozo/upgrade/")
+              .camelize
+              .constantize
+
+            # Write state
+            configuration.backend.state = klass
+              .new(state)
+              .upgrade
+          end
+        end
+
+        def state
+          @state ||= configuration
+            .backend
+            .state(verify: false)
+        end
+      end
+    end
+  end
+end

data/lib/kozo/commands/state.rb

@@ -7,7 +7,7 @@ module Kozo
 
       attr_reader :subcommand
 
-      def initialize(*args)
+      def initialize(configuration, *args)
         subcommand = args.shift
 
         raise UsageError unless subcommand
@@ -16,49 +16,13 @@ module Kozo
 
         raise UsageError, "unknown subcommand: state #{subcommand}" unless klass
 
-        @subcommand = klass.new(*args)
+        @subcommand = klass.new(configuration, *args)
       end
 
       def start
         subcommand
           .start
       end
-
-      class List < State
-        self.description = "List resources in the state"
-
-        def initialize(*_args); end
-
-        def start
-          state
-            .resources
-            .each { |r| Kozo.logger.info r.address }
-        end
-      end
-
-      class Show < State
-        self.description = "Show a resource in the state"
-
-        attr_reader :address
-
-        def initialize(*args)
-          address = args.shift
-
-          raise UsageError, "address not specified" unless address
-
-          @address = address
-        end
-
-        def start
-          resource = state
-            .resources
-            .find { |r| r.address == address }
-
-          raise StateError, "no such resource address: #{address}" unless resource
-
-          Kozo.logger.info Operations::Show.new(resource).to_s
-        end
-      end
     end
   end
 end

data/lib/kozo/concerns/attributes.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/BlockLength
 module Kozo
   module Attributes
     extend ActiveSupport::Concern
@@ -17,19 +18,54 @@ module Kozo
       end
 
       def write_attribute(name, value)
+        attribute_types[name] => { multiple:, type:, wrapped: }
+
         try(:track_change!, name, value)
 
-        value = if attribute_types[name][:multiple]
-                  Array(value).map { |v| attribute_types[name][:type].cast(v) }
-                else
-                  attribute_types[name][:type].cast(value)
-                end
+        # Unwrap value(s) (call #name on receiver)
+        value = value.send_wrap { |v| v.try(:name) || v } if wrapped
+
+        # Cast value(s)
+        value = value.send_wrap { |v| type.cast(v) }
+
+        # Convert value(s) to array
+        value = Array(value) if multiple
 
+        # Set value(s)
         instance_variable_set(:"@#{name}", value)
       end
+
+      def attributes
+        attribute_names
+          .to_h { |name| [name, read_attribute(name)] }
+      end
+
+      def readable_attributes
+        readable_attribute_names
+          .to_h { |name| [name, read_attribute(name)] }
+      end
+
+      def writeable_attributes
+        writeable_attribute_names
+          .to_h { |name| [name, read_attribute(name)] }
+      end
+
+      def creatable_attributes
+        creatable_attribute_names
+          .to_h { |name| [name, read_attribute(name).send_wrap(:as_h)] }
+      end
+
+      def updatable_attributes
+        updatable_attribute_names
+          .to_h { |name| [name, read_attribute(name).send_wrap(:as_h)] }
+      end
+
+      delegate :attribute_names,
+               :readable_attribute_names,
+               :writeable_attribute_names,
+               to: :class
     end
 
-    # rubocop:disable Metrics/BlockLength
     class_methods do
       def inherited(sub_class)
         super
@@ -43,12 +79,13 @@ module Kozo
 
         try(:track, name)
 
-        options = attribute_types[name] = {
+        attribute_types[name] = {
           multiple: !!options[:multiple],
-          attribute: !!options.fetch(:attribute, true),
-          argument: !!options.fetch(:argument, true),
+          wrapped: !!options.fetch(:wrapped, false),
           type: type,
           default: options[:default],
+          read: read?,
+          write: write?,
         }
 
         # Define getter
@@ -57,43 +94,33 @@ module Kozo
           define_method(:"#{name}?") { !!read_attribute(name) }
         end
 
-        # Set visibility to public if it's an attribute
-        options[:attribute] ? public(name) : private(name)
+        # Set getter visibility to private if it's writeonly
+        private(name) if writeonly?
 
         # Define setter
         define_method(:"#{name}=") { |value| write_attribute(name, value) } unless method_defined? :"#{name}="
 
-        # Set visibility to public if it's an argument
-        options[:argument] ? public(:"#{name}=") : private(:"#{name}=")
+        # Set setter visibility to private if it's readonly
+        private(:"#{name}=") if readonly?
       end
 
       def attribute_names
         @attribute_names ||= attribute_types
-          .select { |_k, v| v[:attribute] }
           .keys
       end
 
-      def argument_names
-        @argument_names ||= attribute_types
-          .select { |_k, v| v[:argument] }
+      def readable_attribute_names
+        attribute_types
+          .select { |_k, v| v[:read] }
           .keys
       end
-    end
-    # rubocop:enable Metrics/BlockLength
 
-    def attributes
-      attribute_names
-        .map { |name| [name, read_attribute(name)] }
-        .to_h
-    end
-
-    def arguments
-      argument_names
-        .map { |name| [name, read_attribute(name)] }
-        .to_h
+      def writeable_attribute_names
+        attribute_types
+          .select { |_k, v| v[:write] }
+          .keys
+      end
     end
-
-    delegate :attribute_names, to: :class
-    delegate :argument_names, to: :class
   end
 end
+# rubocop:enable Metrics/BlockLength

data/lib/kozo/concerns/read_write.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Kozo
+  module ReadWrite
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :mode, default: :readwrite
+    end
+
+    class_methods do
+      def readwrite
+        self.mode = :readwrite
+      end
+
+      def readwrite?
+        mode == :readwrite
+      end
+
+      def readonly
+        self.mode = :read
+      end
+
+      def readonly?
+        mode == :read
+      end
+
+      def read?
+        mode == :read || mode == :readwrite
+      end
+
+      def writeonly
+        self.mode = :write
+      end
+
+      def writeonly?
+        mode == :write
+      end
+
+      def write?
+        mode == :write || mode == :readwrite
+      end
+    end
+  end
+end

data/lib/kozo/configuration.rb

@@ -11,42 +11,53 @@ module Kozo
       @resources = Set.new
     end
 
-    def backend
-      @backend ||= Kozo
-        .container
-        .resolve("backend.local", self, directory)
-    end
-
     def changes
       @changes ||= begin
         # Copy resources in state
-        changes = backend
-          .state
+        changes = state
           .resources
           .map(&:dup)
           .each(&:clear_changes)
           .each do |resource|
+          # Find resource in configuration
           configured = resources.find { |r| r.address == resource.address }
 
-          # Assign updated attributes (mark for update)
-          resource.assign_attributes(configured&.attributes&.except(:id) || resource.attributes.except(:id).transform_values { nil })
-
-          # Mark for deletion
-          resource.mark_for_deletion! unless configured
+          if configured
+            # Assign updated attributes (mark for update)
+            resource.assign_attributes(configured&.readable_attributes&.slice(*configured&.updatable_attribute_names))
+          else
+            # Set attributes to nil (mark for destruction)
+            resource.assign_attributes(resource.readable_attributes.transform_values { nil })
+          end
         end
 
-        # Append resources not in state
+        # Append resources not in state (mark for creation)
         changes += resources
-          .reject { |r| backend.state.resources.any? { |res| res.address == r.address } }
-          .map { |r| r.class.new(state_name: r.state_name, **r.arguments) }
-          .each(&:mark_for_creation!)
+          .reject { |r| state.resources.any? { |res| res.address == r.address } }
+          .map { |r| r.class.new(state_name: r.state_name, **r.writeable_attributes) }
+
+        # Resolve references
+        changes
+          .each { |c| c.writeable_attributes.each_value { |r| r.send_wrap(:try, :resolve, self) } }
 
         changes
       end
     end
 
+    def backend
+      @backend ||= Kozo
+        .container
+        .resolve("backend.local", self, directory)
+    end
+
+    delegate :state, to: :backend
+
     def to_s
       "directory: #{directory}"
     end
+
+    def inspect
+      "#<#{self.class.name} #{self}>"
+    end
   end
 end

data/lib/kozo/dsl.rb

@@ -45,6 +45,21 @@ module Kozo
       configuration.resources << resource
     end
 
+    def method_missing(method_name, *arguments, &block)
+      resource_class = Kozo
+        .container
+        .resolve("resource.#{method_name}")
+        .class
+
+      Reference.new(resource_class: resource_class)
+    rescue Dinja::Container::DependencyNotRegistered
+      super
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      Kozo.container.resolve!("resource.#{method_name}").present? || super
+    end
+
     private
 
     def resolve(resource, type, *args)

data/lib/kozo/error.rb

@@ -1,13 +1,24 @@
 # frozen_string_literal: true
 
 module Kozo
+  # Base class
   class Error < StandardError; end
 
-  class InvalidResource < Error; end
-
+  # Raised when usage is printed
   class ExitError < Error; end
 
+  # Raised when CLI arguments are invalid
   class UsageError < Error; end
 
+  # Raised when a resource definition was invalid
+  class InvalidResource < Error; end
+
+  # Raised when a resource cannot match constraints (uniqueness, etc.)
+  class ResourceError < Error; end
+
+  # Raised when state invalid or resource not found in state
   class StateError < Error; end
+
+  # Raised when performing an operation on a resource that was not persisted yet
+  class NotPersisted < Error; end
 end

data/lib/kozo/inflector.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kozo
+  class Inflector < Zeitwerk::GemInflector
+    def camelize(basename, abspath)
+      return super(Regexp.last_match(2), abspath) if basename =~ /\A(\d+)_(.*)/ && abspath.include?("kozo/upgrade")
+
+      super
+    end
+  end
+end

data/lib/kozo/logger.rb

@@ -12,16 +12,12 @@ module Kozo
     private
 
     def level
-      Kozo.options.verbose? ? "debug" : ENV.fetch("LOG_LEVEL", "info")
+      Kozo.options.verbose? ? "debug" : "info"
     end
 
     def formatter
-      Formatter.new
-    end
-
-    class Formatter < ::Logger::Formatter
-      def call(severity, _time, _progname, msg)
-        abort("#{File.basename($PROGRAM_NAME)}: #{msg[0].downcase}#{msg[1..]}".white.on_red) if severity == "FATAL"
+      proc do |severity, _time, _progname, msg|
+        abort("#{File.basename($PROGRAM_NAME)}: #{msg}".white.on_red) if severity == "FATAL"
 
         msg = "#{msg}\n"
         msg = msg.yellow if severity == "DEBUG"
@@ -30,5 +26,15 @@ module Kozo
         msg
       end
     end
+
+    class Debug < Logger
+      def level
+        Kozo.options.debug? ? "debug" : "fatal"
+      end
+
+      def formatter
+        ->(_severity, _time, _progname, msg) { msg.magenta }
+      end
+    end
   end
 end

data/lib/kozo/operation.rb

@@ -13,30 +13,5 @@ module Kozo
     def apply(_state)
       raise NotImplementedError
     end
-
-    def to_s
-      resource_to_s
-    end
-
-    protected
-
-    def resource_to_s
-      <<~DSL.chomp
-        #{"# #{resource.address}:".bold}
-        #{display_symbol} resource "#{resource.resource_name}", "#{resource.state_name}" do |r|
-          #{attributes_to_s}
-        end
-
-      DSL
-    end
-
-    def attributes_to_s
-      l = resource.attribute_names.map(&:length).max || 1
-
-      resource
-        .attributes
-        .map { |k, v| "#{resource.changes.key?(k) ? display_symbol : ' '}  r.#{k.to_s.ljust(l)} = \"#{v.to_s.chomp.truncate(75)}\"" }
-        .join("\n  ")
-    end
   end
 end

data/lib/kozo/operations/create.rb

@@ -14,15 +14,21 @@ module Kozo
         state.resources << resource
       end
 
-      protected
-
-      def attributes_to_s
+      def to_s
         l = resource.attribute_names.map(&:length).max || 1
 
-        resource
+        attrs = resource
           .attributes
-          .map { |k, v| "#{resource.changes.key?(k) ? display_symbol : ' '}  r.#{k.to_s.ljust(l)} = #{v.blank? ? '(known after apply)' : "\"#{v.to_s.chomp.truncate(75)}\""}" }
-          .join("\n  ")
+          .map { |k, v| "  #{resource.changes.key?(k) ? display_symbol : ' '} r.#{k.to_s.ljust(l)} = #{v.blank? && resource.writeable_attribute_names.exclude?(k) ? '(known after apply)' : (v.as_s.indent(4)[4..]).to_s}" }
+          .join("\n")
+
+        <<~DSL.chomp
+          #{"# #{resource.address}:".bold}
+          #{display_symbol} resource "#{resource.resource_name}", "#{resource.state_name}" do |r|
+          #{attrs}
+          end
+
+        DSL
       end
     end
   end

data/lib/kozo/operations/destroy.rb

@@ -14,15 +14,21 @@ module Kozo
         state.resources.delete(resource)
       end
 
-      protected
-
-      def attributes_to_s
+      def to_s
         l = resource.attribute_names.map(&:length).max || 1
 
-        resource
+        attrs = resource
           .attribute_names
-          .map { |k| "#{display_symbol}  r.#{k.to_s.ljust(l)} = \"#{resource.send(:"#{k}_was").to_s.chomp.truncate(75)}\"" }
-          .join("\n  ")
+          .map { |k| "  #{display_symbol} r.#{k.to_s.ljust(l)} = #{resource.send(:"#{k}_was").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