avm 0.44.0 → 0.46.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75da0735d17a4472beabdba8b1a848bd1df14e0e8b630885bbf2b1503d198e14
-  data.tar.gz: 4d71ad19868decc5d8eebcd01b71a1a518702345a06521edb0c27f55bd25cca5
+  metadata.gz: 3de16327c43ae558d30a57324fcbaa23da1546da8110c4de0ba502003d6ac42c
+  data.tar.gz: 1bc7005ac83d1191579db59161d656fb4054e35f23c611a46c563df5351c6213
 SHA512:
-  metadata.gz: 8e75c632a176c1f15431466cf0fe85c53fcbaccf5d914e643b7a5a51ef17bc8a41ea7c5b2d6253feb0587557d01d66a40b7073ac375115f7e07afe1ffa13d694
-  data.tar.gz: d3c82791118497839cea0c53d9e8d838dedf1db1a7f462c022ea24d82411774f86db27b9e0e8d40b844a09ad6c2f918f0b23802f58f489e03490bc52f10d526f
+  metadata.gz: 893701096abafe979997222cce3150766e944369ad8cb089f4022acfe1673d4651529dfa9b63e8b585028c8cac2f1a394aba20627b8b1b37d73f3ee0b4089d34
+  data.tar.gz: 5c042ea77b1f9daf6b29ea86484ecf24b9ac4eef274eb4c1999a612ae8f92dc3173b3b492c62fb364bb76c89fd8c6406fc46104a8ec652e00803e1dc631ed4a5

data/lib/avm/entries/auto_values/entry.rb

@@ -8,15 +8,22 @@ module Avm
     module AutoValues
       class Entry
         class << self
-          def auto_value_method_name(suffix)
-            "auto_#{suffix.to_s.gsub('.', '_')}"
+          # @param path [EacConfig::EntryPath]
+          # @return String
+          def auto_value_method_name(path)
+            "auto_#{::EacConfig::EntryPath.assert(path).to_string.gsub('.', '_')}"
           end
         end
 
-        common_constructor :entries_provider, :suffix
+        # @!method initialize(entries_provider, path)
+        #   @param entries_provider
+        #   @param path [EacConfig::EntryPath]
+        common_constructor :entries_provider, :path do
+          self.path = ::EacConfig::EntryPath.assert(path)
+        end
 
         def auto_value_method
-          self.class.auto_value_method_name(suffix)
+          self.class.auto_value_method_name(path)
         end
 
         def found?

data/lib/avm/entries/jobs/base.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'avm/entries/jobs/with_variables_source'
+require 'avm/result'
+require 'eac_cli/core_ext'
+
+module Avm
+  module Entries
+    module Jobs
+      module Base
+        common_concern do
+          include ::ActiveSupport::Callbacks
+          include ::Avm::Entries::Jobs::WithVariablesSource
+
+          enable_speaker
+          enable_simple_cache
+          enable_listable
+          common_constructor :instance, :options, default: [{}] do
+            if option_list.present?
+              self.options = option_list.hash_keys_validate!(options.symbolize_keys)
+            end
+          end
+          define_callbacks(*jobs)
+        end
+
+        module ClassMethods
+          def jobs
+            const_get('JOBS').dup
+          end
+        end
+
+        module InstanceMethods
+          def option_list
+            nil
+          end
+
+          def run
+            start_banner if respond_to?(:start_banner)
+            run_jobs
+            ::Avm::Result.success('Done!')
+          rescue ::Avm::Result::Error => e
+            e.to_result
+          end
+
+          protected
+
+          def run_jobs
+            jobs.each do |job|
+              run_callbacks job do
+                send(job)
+              end
+            end
+          end
+
+          def jobs
+            self.class.jobs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/entries/jobs/variables_source/read_entry.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Entries
+    module Jobs
+      class VariablesSource
+        class ReadEntry
+          enable_method_class
+          common_constructor :variables_source, :path, :options, default: [{}]
+          delegate :instance, :job, to: :variables_source
+
+          def result
+            return result_from_job if result_from_job?
+            return result_from_instance_method if result_from_instance_method?
+
+            result_from_instance_entry
+          end
+
+          private
+
+          def path_method_name
+            path.gsub('.', '_').underscore
+          end
+
+          def result_from_instance_entry
+            instance.read_entry(path, options)
+          end
+
+          def result_from_instance_method
+            instance.send(path_method_name)
+          end
+
+          def result_from_instance_method?
+            instance.respond_to?(path_method_name, true)
+          end
+
+          def result_from_job
+            job.send(path_method_name)
+          end
+
+          def result_from_job?
+            job.respond_to?(path_method_name, true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/entries/jobs/variables_source.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Entries
+    module Jobs
+      class VariablesSource
+        require_sub __FILE__, require_dependency: true
+        common_constructor :job
+        delegate :instance, to: :job
+      end
+    end
+  end
+end

data/lib/avm/entries/jobs/with_variables_source.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'avm/entries/jobs/variables_source'
+
+module Avm
+  module Entries
+    module Jobs
+      module WithVariablesSource
+        def variables_source
+          ::Avm::Entries::Jobs::VariablesSource.new(self)
+        end
+      end
+    end
+  end
+end

data/lib/avm/{jobs.rb → entries/jobs.rb}

@@ -3,7 +3,9 @@
 require 'eac_ruby_utils/core_ext'
 
 module Avm
-  module Jobs
-    require_sub __FILE__
+  module Entries
+    module Jobs
+      require_sub __FILE__
+    end
   end
 end

data/lib/avm/instances/base/entry_keys.rb

@@ -13,7 +13,7 @@ module Avm
           end
 
           define_method "#{method_name}_optional" do
-            read_entry(key, required: false)
+            read_entry_optional(key)
           end
         end
       end

data/lib/avm/instances/entry_keys.rb

@@ -35,7 +35,7 @@ module Avm
           '' => %w[id from reply_to],
           smtp: URI_FIELDS + %w[address domain authentication openssl_verify_mode starttls_auto tls]
         },
-        web: URI_FIELDS + %w[authority userinfo]
+        web: URI_FIELDS
       }.each { |prefix, suffixes| keys_consts_set(prefix, suffixes) }
     end
   end

data/lib/avm/launcher/context/instance_collector.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceCollector
+        common_constructor :context
+
+        def add_all
+          instances_set.merge(context.instances)
+          self
+        end
+
+        def add_path(path)
+          instances_set.merge(instances_on_path(path))
+          self
+        end
+
+        def add_pending
+          instances_set.merge(context.pending_instances)
+          self
+        end
+
+        def instances
+          instances_set.sort
+        end
+
+        private
+
+        def instance_match?(instance, instance_name)
+          ::File.fnmatch?(instance_name, instance.name)
+        end
+
+        def instances_on_path(path)
+          context.instances.select { |instance| instance_match?(instance, path) }
+        end
+
+        def instances_set
+          @instances_set ||= ::Set.new
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/context/instance_discovery.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'ruby-progressbar'
+require 'avm/launcher/instances/base'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceDiscovery
+        attr_reader :instances
+
+        def initialize(context)
+          @context = context
+          @progress = ::ProgressBar.create(title: 'Instance discovery', total: 1)
+          @instances = path_instances(@context.root, nil)
+        ensure
+          @progress&.finish
+        end
+
+        private
+
+        def path_instances(path, parent_instance)
+          update_progress_format(path)
+          on_rescued_path_instances(path) do |r|
+            if path.project?
+              parent_instance = ::Avm::Launcher::Instances::Base.instanciate(path, parent_instance)
+              r << path
+            end
+            children = path.children
+            update_progress_count(children)
+            r.concat(children.flat_map { |c| path_instances(c, parent_instance) })
+          end
+        end
+
+        def on_rescued_path_instances(path)
+          r = []
+          begin
+            yield(r) if path.included?
+          rescue StandardError => e
+            warn("#{path}: #{e}")
+          end
+          r
+        end
+
+        def update_progress_format(path)
+          @progress.format = "%t (Paths: %c/%C, Current: #{path.logical}) |%B| %a"
+        end
+
+        def update_progress_count(children)
+          @progress.total += children.count
+          @progress.increment
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/context/instance_manager/cached_instance.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/instances/base'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceManager
+        class CachedInstance
+          enable_speaker
+          enable_simple_cache
+          common_constructor :cached_instances, :data
+
+          private
+
+          def instance_uncached
+            ::Avm::Launcher::Instances::Base.instanciate(path, parent_instance)
+          rescue ::Avm::Launcher::Errors::NonProject
+            warn "Cached instance \"#{data[:logical]}\" not found"
+            nil
+          end
+
+          def parent_instance_uncached
+            data[:parent]
+              .if_present { |v| cached_instances.by_logical_path(v) }
+              .if_present(&:instance)
+          end
+
+          def path_uncached
+            ::Avm::Launcher::Paths::Logical.from_h(cached_instances.context, data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/context/instance_manager/cached_instances.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/context/instance_manager/cached_instance'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceManager
+        class CachedInstances
+          enable_simple_cache
+          common_constructor :context, :content
+
+          def instances
+            content.keys.map { |k| by_logical_path(k).instance }.reject(&:blank?)
+          end
+
+          def by_logical_path(key)
+            cached_instances[key].if_blank do
+              cached_instances[key] = ::Avm::Launcher::Context::InstanceManager::CachedInstance.new(
+                self, content.fetch(key)
+              )
+            end
+          end
+
+          private
+
+          def cached_instances_uncached
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/context/instance_manager.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/launcher/publish/check_result'
+require('yaml')
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceManager
+        require_sub __FILE__
+        enable_simple_cache
+        common_constructor :context
+
+        def publish_state_set(instance, stereotype_name, check_status)
+          data = cached_instances_file_content_uncached
+          data[instance.logical] ||= {}
+          data[instance.logical][:publish_state] ||= {}
+          data[instance.logical][:publish_state][stereotype_name] = check_status
+          write_cache_file(data)
+        end
+
+        def pending_instances
+          instances.select { |instance| pending_instance?(instance) }
+        end
+
+        private
+
+        def instances_uncached
+          (cached_instances || search_instances).select(&:included?)
+        end
+
+        def search_instances
+          cache_instances(::Avm::Launcher::Context::InstanceDiscovery.new(context).instances)
+        end
+
+        def cached_instances
+          return nil if context.recache
+          return nil unless cached_instances_file_content
+
+          CachedInstances.new(self, cached_instances_file_content).instances
+        end
+
+        def cached_instances_file_content_uncached
+          r = YAML.load_file(cache_file_path)
+          r.is_a?(::Hash) ? r : nil
+        rescue Errno::ENOENT
+          nil
+        end
+
+        def cache_instances(instances)
+          write_cache_file(Hash[instances.map { |i| [i.logical, i.to_h] }])
+          instances
+        end
+
+        def write_cache_file(data)
+          ::File.write(cache_file_path, data.to_yaml)
+        end
+
+        def cache_file_path
+          ::File.join(context.cache_root, 'instances.yml')
+        end
+
+        def pending_instance?(instance)
+          data = cached_instances_file_content
+          return false unless data[instance.logical]
+          return false unless data[instance.logical][:publish_state].is_a?(Hash)
+
+          data[instance.logical][:publish_state].any? do |_k, v|
+            ::Avm::Launcher::Publish::CheckResult.pending_status?(v)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/context/settings.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/instances/settings'
+require 'eac_ruby_utils/simple_cache'
+require 'yaml'
+
+module Avm
+  module Launcher
+    class Context
+      class Settings
+        include ::EacRubyUtils::SimpleCache
+
+        def initialize(file)
+          unless ::File.exist?(file)
+            ::FileUtils.mkdir_p(::File.dirname(file))
+            ::File.write(file, {}.to_yaml)
+          end
+          @data = YAML.load_file(file)
+        end
+
+        def instance_settings(instance)
+          ::Avm::Launcher::Instances::Settings.new(value(['Instances', instance.name]))
+        end
+
+        private
+
+        def excluded_projects_uncached
+          enum_value(%w[Projects Exclude])
+        end
+
+        def excluded_paths_uncached
+          enum_value(%w[Paths Exclude])
+        end
+
+        def enum_value(path)
+          r = value(path)
+          r.is_a?(Enumerable) ? r : []
+        end
+
+        def value(path)
+          node_value(@data, path)
+        end
+
+        def node_value(data, path)
+          return data if path.empty?
+          return nil unless data.is_a?(Hash)
+
+          node_value(data[path.first], path.drop(1))
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/context.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/indifferent_access'
+require 'avm/launcher/context/instance_manager'
+require 'eac_ruby_utils/simple_cache'
+require 'eac_cli/speaker'
+require 'avm/launcher/context/instance_discovery'
+require 'avm/launcher/context/settings'
+require 'avm/launcher/paths/logical'
+require 'avm/launcher/project'
+require 'avm/tools/self'
+
+module Avm
+  module Launcher
+    class Context
+      include ::EacRubyUtils::SimpleCache
+      enable_speaker
+
+      class << self
+        attr_writer :current
+
+        def current
+          @current ||= default
+        end
+
+        def default
+          @default ||= Context.new
+        end
+      end
+
+      attr_reader :root, :settings, :cache_root
+      attr_accessor :publish_options, :recache, :instance_manager
+
+      CONFIG_PATH_PREFIX = 'launcher'
+
+      def initialize(options = {})
+        @options = options.with_indifferent_access
+        @root = ::Avm::Launcher::Paths::Logical.new(self, nil, build_option(:projects_root), '/')
+        @settings = ::Avm::Launcher::Context::Settings.new(build_option(:settings_file))
+        @cache_root = build_option(:cache_root)
+        @publish_options = { new: false, confirm: false, stereotype: nil }
+        @instance_manager = ::Avm::Launcher::Context::InstanceManager.new(self)
+        @recache = false
+      end
+
+      def instance(name)
+        instances.find { |i| i.name == name }
+      end
+
+      def instances
+        @instance_manager.instances
+      end
+
+      def pending_instances
+        @instance_manager.pending_instances
+      end
+
+      private
+
+      def build_option(key)
+        @options[key] || config_option(key) || default_option(key)
+      end
+
+      def config_option(key)
+        ::Avm::Self::Instance.default.entry([CONFIG_PATH_PREFIX, key].join('.')).optional_value
+      end
+
+      def default_cache_root
+        ::Avm::Tools::Self.application.cache_dir.join('launcher')
+      end
+
+      def default_option(key)
+        send("default_#{key}".underscore)
+      end
+
+      def default_projects_root
+        '.'
+      end
+
+      def default_settings_file
+        ::Avm::Tools::Self.application.config_dir.join('launcher.yaml')
+      end
+
+      def projects_uncached
+        r = {}
+        instances.each do |i|
+          r[i.project_name] ||= []
+          r[i.project_name] << i
+        end
+        r.map { |name, instances| ::Avm::Launcher::Project.new(name, instances) }
+      end
+    end
+  end
+end

data/lib/avm/launcher/instances/base/cache.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Avm
+  module Launcher
+    module Instances
+      module Base
+        module Cache
+          def cache_path(subpath)
+            File.join(cache_root, subpath)
+          end
+
+          def cache_key(key, &block)
+            v = cache_key_get(key)
+            return v if v.present? || block.nil?
+
+            v = yield
+            cache_key_write(key, v)
+            v
+          end
+
+          private
+
+          def cache_key_get(key)
+            File.file?(cache_key_path(key)) ? File.read(cache_key_path(key)) : nil
+          end
+
+          def cache_key_write(key, value)
+            FileUtils.mkdir_p(File.dirname(cache_key_path(key)))
+            File.write(cache_key_path(key), value)
+          end
+
+          def cache_key_path(key)
+            File.join(cache_root, 'keys', key.parameterize)
+          end
+
+          def cache_root
+            File.join(::Avm::Launcher::Context.current.cache_root, name.parameterize)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/instances/base.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative 'base/cache'
+require 'avm/launcher/errors/non_project'
+require 'eac_ruby_utils/speaker/sender'
+
+module Avm
+  module Launcher
+    module Instances
+      module Base
+        class << self
+          def extend_object(object)
+            object.extend ::EacRubyUtils::SimpleCache
+            object.extend ::EacRubyUtils::Speaker::Sender
+            object.extend ::Avm::Launcher::Instances::Base::Cache
+            super
+          end
+
+          def instanciate(path, parent)
+            unless path.is_a?(::Avm::Launcher::Instances::Base)
+              raise ::Avm::Launcher::Errors::NonProject, path unless path.project?
+
+              path.extend(::Avm::Launcher::Instances::Base)
+              path.parent = parent
+            end
+            path
+          end
+        end
+
+        attr_accessor :parent
+
+        def name
+          logical
+        end
+
+        def stereotype?(stereotype)
+          stereotypes.include?(stereotype)
+        end
+
+        def to_parent_path
+          return self unless @parent
+
+          logical.gsub(/\A#{Regexp.quote(@parent.logical)}/, '')
+        end
+
+        def project?
+          stereotypes.any?
+        end
+
+        def publish_run
+          stereotypes.each do |s|
+            next unless publish?(s)
+
+            infov(name, "publishing #{s.label}")
+            s.publish_class.new(self).run
+          end
+        end
+
+        def publish_check
+          stereotypes.each do |s|
+            next unless publish?(s)
+
+            puts "#{name.to_s.cyan}|#{s.label}|" \
+              "#{s.publish_class.new(self).check}"
+          end
+        end
+
+        def project_name
+          ::File.basename(logical)
+        end
+
+        def included?
+          !::Avm::Launcher::Context.current.settings.excluded_projects.include?(project_name)
+        end
+
+        def to_h
+          super.to_h.merge(parent: parent ? parent.logical : nil)
+        end
+
+        private
+
+        def publish?(stereotype)
+          return false unless stereotype.publish_class
+          return false unless options.stereotype_publishable?(stereotype)
+
+          filter = ::Avm::Launcher::Context.current.publish_options[:stereotype]
+          filter.blank? ? true : filter == stereotype.name.demodulize
+        end
+
+        def options_uncached
+          ::Avm::Launcher::Context.current.settings.instance_settings(self)
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/instances/error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Avm
+  module Launcher
+    module Instances
+      class Error < StandardError
+      end
+    end
+  end
+end

data/lib/avm/launcher/instances/runner_helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/context'
+require 'avm/tools/core_ext'
+require 'avm/launcher/context/instance_collector'
+
+module Avm
+  module Launcher
+    module Instances
+      module RunnerHelper
+        common_concern do
+          runner_definition do
+            bool_opt '--all', 'Select all instances.'
+            bool_opt '--pending', 'Select pending instances.'
+            bool_opt '--recache', 'Rewrite instances cache.'
+          end
+
+          set_callback :run, :before, :setup_cache
+        end
+
+        def context
+          @context ||= ::Avm::Launcher::Context.current
+        end
+
+        def instances
+          collector = ::Avm::Launcher::Context::InstanceCollector.new(context)
+          collector.add_all if parsed.all?
+          collector.add_pending if parsed.pending?
+          parsed.instance_path.flat_map { |p| collector.add_path(p) }
+          collector.instances
+        end
+
+        def instance_stereotypes(instance)
+          instance.stereotypes.map(&:label).join(', ')
+        end
+
+        def instance_label(instance)
+          "#{instance.name} [#{instance_stereotypes(instance)}]"
+        end
+
+        def setup_cache
+          ::Avm::Launcher::Context.current.recache = parsed.recache?
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/instances/settings.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    module Instances
+      class Settings
+        DEFAULT_CURRENT_REVISION = 'origin/master'
+        DEFAULT_PUBLISH_REMOTE = 'publish'
+        PUBLISHABLE_KEY = :publishable
+
+        common_constructor :data do
+          self.data = (data.is_a?(Hash) ? data : {}).with_indifferent_access
+        end
+
+        def git_current_revision
+          data[__method__] || DEFAULT_CURRENT_REVISION
+        end
+
+        def git_publish_remote
+          data[__method__] || DEFAULT_PUBLISH_REMOTE
+        end
+
+        def publishable?
+          publishable_value ? true : false
+        end
+
+        def stereotype_publishable?(stereotype)
+          return publishable? unless publishable_value.is_a?(::Hash)
+
+          parse_publishable_value(publishable_value[stereotype.stereotype_name], true)
+        end
+
+        private
+
+        def publishable_value
+          parse_publishable_value(data[PUBLISHABLE_KEY], false)
+        end
+
+        def parse_publishable_value(value, hash_to_true)
+          return value.with_indifferent_access if parse_publishable_value_hash?(value, hash_to_true)
+          return true if value.nil? || value == true
+          return false if value == false
+
+          value ? true : false
+        end
+
+        def parse_publishable_value_hash?(value, hash_to_true)
+          !hash_to_true && value.is_a?(::Hash)
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/paths/logical.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'avm/projects/stereotypes'
+require 'avm/launcher/paths/real'
+
+module Avm
+  module Launcher
+    module Paths
+      class Logical
+        include ::Comparable
+        include ::EacRubyUtils::SimpleCache
+
+        class << self
+          def from_h(context, hash)
+            parent_path = hash[:parent_path] ? from_h(context, hash[:parent_path]) : nil
+            new(context, parent_path, hash[:real], hash[:logical])
+          end
+        end
+
+        attr_reader :context, :real, :logical, :parent_path
+
+        def initialize(context, parent_path, real, logical)
+          @context = context
+          @parent_path = parent_path
+          @real = ::Avm::Launcher::Paths::Real.new(real)
+          @logical = logical
+        end
+
+        def <=>(other)
+          [logical, real] <=> [other.logical, other.real]
+        end
+
+        def to_s
+          logical
+        end
+
+        def to_h
+          { logical: logical, real: real.to_s, parent_path: parent_path ? parent_path.to_h : nil }
+        end
+
+        def project?
+          stereotypes.any?
+        end
+
+        def children
+          r = []
+          Dir.entries(warped).each do |c|
+            c_path = ::File.join(warped, c)
+            next unless ::File.directory?(c_path)
+            next if c.start_with?('.')
+
+            r << build_child(c)
+          end
+          r
+        end
+
+        def included?
+          !context.settings.excluded_paths.include?(logical)
+        end
+
+        private
+
+        def stereotypes_uncached
+          ::Avm::Projects::Stereotype.stereotypes.select { |s| s.match?(self) }
+        end
+
+        def build_child(name)
+          ::Avm::Launcher::Paths::Logical.new(
+            context,
+            self,
+            ::File.join(warped, name),
+            ::File.join(logical, name)
+          )
+        end
+
+        def warped_uncached
+          if is_a?(::Avm::Launcher::Instances::Base)
+            stereotypes.each do |s|
+              return s.warp_class.new(self) if s.warp_class
+            end
+          end
+          real
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/publish/base.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/errors/base'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    module Publish
+      class Base
+        common_constructor :instance
+
+        def run
+          s = check
+          info("Check: #{s}")
+          return unless s.status == ::Avm::Launcher::Publish::CheckResult::STATUS_PENDING
+
+          publish
+        end
+
+        def check
+          s = check_with_rescue
+          ::Avm::Launcher::Context.current.instance_manager.publish_state_set(
+            instance, stereotype.stereotype_name, s.status
+          )
+          s
+        end
+
+        private
+
+        def stereotype
+          self.class.name.deconstantize.constantize
+        end
+
+        def check_with_rescue
+          internal_check
+        rescue ::Avm::Launcher::Errors::Base => e
+          ::Avm::Launcher::Publish::CheckResult.blocked("Error: #{e}")
+        rescue ::Avm::Launcher::Git::Error => e
+          ::Avm::Launcher::Publish::CheckResult.blocked("Git error: #{e}")
+        end
+      end
+    end
+  end
+end

data/lib/avm/registry.rb

@@ -10,8 +10,6 @@ module Avm
     lists.add_symbol :category, :application_stereotypes, :instances, :runners, :scms,
                      :source_generators, :sources
 
-    WITH_PATH = [CATEGORY_SCMS, CATEGORY_SOURCES].freeze
-
     class << self
       enable_simple_cache
 

data/lib/avm/rspec/setup.rb

@@ -5,17 +5,16 @@ require 'eac_ruby_utils/core_ext'
 module Avm
   module Rspec
     module Setup
-      def self.extended(obj)
-        obj.setup_in_avm_registry_example
-        obj.setup_not_in_avm_registry_example
-      end
+      EXAMPLES = %w[entries_values in_avm_registry not_in_avm_registry].freeze
 
-      def setup_in_avm_registry_example
-        require 'avm/rspec/shared_examples/in_avm_registry'
+      def self.extended(obj)
+        obj.setup_examples
       end
 
-      def setup_not_in_avm_registry_example
-        require 'avm/rspec/shared_examples/not_in_avm_registry'
+      def setup_examples
+        EXAMPLES.each do |example|
+          require "avm/rspec/shared_examples/#{example}"
+        end
       end
     end
   end

data/lib/avm/rspec/shared_examples/entries_values.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+::RSpec.shared_examples 'entries_values' do |spec_file, expected_values|
+  describe '#read_entry' do
+    config_path = spec_file.to_pathname
+    config_path = config_path.dirname.join("#{config_path.basename_noext}_files", 'config.yml')
+    ::EacRubyUtils::Rspec.default_setup.stub_eac_config_node(self, config_path)
+
+    expected_values.each do |instance_id, values|
+      values.each do |input, expected|
+        context "when a auto value is requested for \"#{instance_id}.#{input}\"" do
+          let(:instance) { described_class.by_id(instance_id) }
+
+          it ".read_entry should return \"#{expected}\"" do
+            expect(instance.read_entry(input)).to eq(expected)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Avm
-  VERSION = '0.44.0'
+  VERSION = '0.46.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avm
 version: !ruby/object:Gem::Version
-  version: 0.44.0
+  version: 0.46.0
 platform: ruby
 authors:
 - Eduardo H. Bogoni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-09-22 00:00:00.000000000 Z
+date: 2022-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eac_cli
@@ -50,20 +50,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.4.2
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.4.2
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: eac_git
   requirement: !ruby/object:Gem::Requirement
@@ -73,7 +67,7 @@ dependencies:
         version: '0.12'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.12.2
+        version: 0.12.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -83,7 +77,7 @@ dependencies:
         version: '0.12'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.12.2
+        version: 0.12.3
 - !ruby/object:Gem::Dependency
   name: eac_ruby_utils
   requirement: !ruby/object:Gem::Requirement
@@ -241,6 +235,11 @@ files:
 - lib/avm/entries/base/uri_components_entries_values/path_component.rb
 - lib/avm/entries/base/uri_components_entries_values/url_component.rb
 - lib/avm/entries/entry.rb
+- lib/avm/entries/jobs.rb
+- lib/avm/entries/jobs/base.rb
+- lib/avm/entries/jobs/variables_source.rb
+- lib/avm/entries/jobs/variables_source/read_entry.rb
+- lib/avm/entries/jobs/with_variables_source.rb
 - lib/avm/entries/keys_constants_set.rb
 - lib/avm/entries/uri_builder.rb
 - lib/avm/executables.rb
@@ -259,12 +258,23 @@ files:
 - lib/avm/instances/docker_image.rb
 - lib/avm/instances/entry_keys.rb
 - lib/avm/instances/runner.rb
-- lib/avm/jobs.rb
-- lib/avm/jobs/base.rb
-- lib/avm/jobs/variables_source.rb
+- lib/avm/launcher/context.rb
+- lib/avm/launcher/context/instance_collector.rb
+- lib/avm/launcher/context/instance_discovery.rb
+- lib/avm/launcher/context/instance_manager.rb
+- lib/avm/launcher/context/instance_manager/cached_instance.rb
+- lib/avm/launcher/context/instance_manager/cached_instances.rb
+- lib/avm/launcher/context/settings.rb
 - lib/avm/launcher/errors/base.rb
 - lib/avm/launcher/errors/non_project.rb
+- lib/avm/launcher/instances/base.rb
+- lib/avm/launcher/instances/base/cache.rb
+- lib/avm/launcher/instances/error.rb
+- lib/avm/launcher/instances/runner_helper.rb
+- lib/avm/launcher/instances/settings.rb
+- lib/avm/launcher/paths/logical.rb
 - lib/avm/launcher/paths/real.rb
+- lib/avm/launcher/publish/base.rb
 - lib/avm/launcher/publish/check_result.rb
 - lib/avm/path_string.rb
 - lib/avm/registry.rb
@@ -282,6 +292,7 @@ files:
 - lib/avm/result.rb
 - lib/avm/rspec.rb
 - lib/avm/rspec/setup.rb
+- lib/avm/rspec/shared_examples/entries_values.rb
 - lib/avm/rspec/shared_examples/in_avm_registry.rb
 - lib/avm/rspec/shared_examples/not_in_avm_registry.rb
 - lib/avm/runners/base.rb

data/lib/avm/jobs/base.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/jobs/variables_source'
-require 'avm/result'
-require 'eac_cli/core_ext'
-
-module Avm
-  module Jobs
-    module Base
-      common_concern do
-        include ::ActiveSupport::Callbacks
-
-        enable_speaker
-        enable_simple_cache
-        enable_listable
-        common_constructor :instance, :options, default: [{}] do
-          if option_list.present?
-            self.options = option_list.hash_keys_validate!(options.symbolize_keys)
-          end
-        end
-        define_callbacks(*jobs)
-      end
-
-      module ClassMethods
-        def jobs
-          const_get('JOBS').dup
-        end
-      end
-
-      module InstanceMethods
-        def option_list
-          nil
-        end
-
-        def run
-          start_banner if respond_to?(:start_banner)
-          run_jobs
-          ::Avm::Result.success('Done!')
-        rescue ::Avm::Result::Error => e
-          e.to_result
-        end
-
-        def variables_source
-          ::Avm::Jobs::VariablesSource.new(self, instance)
-        end
-
-        protected
-
-        def run_jobs
-          jobs.each do |job|
-            run_callbacks job do
-              send(job)
-            end
-          end
-        end
-
-        def jobs
-          self.class.jobs
-        end
-      end
-    end
-  end
-end

data/lib/avm/jobs/variables_source.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module Avm
-  module Jobs
-    class VariablesSource
-      common_constructor :job, :instance
-
-      def read_entry(path, options = {})
-        entry_from_job(path) || instance.read_entry(path, options)
-      end
-
-      private
-
-      def entry_from_job(path)
-        method = path.gsub('.', '_').underscore
-        return job.send(method) if job.respond_to?(method, true)
-      end
-    end
-  end
-end