eac_tools 0.104.0 → 0.105.1

data/sub/avm/lib/avm/instances/runner.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/core_ext'
-
-module Avm
-  module Instances
-    class Runner < ::Avm::Runners::Base
-      runner_with :help, :subcommands do
-        desc 'Utilities for a instance.'
-        pos_arg 'instance-id'
-        subcommands
-      end
-
-      delegate :class, to: :instance, prefix: true
-      for_context :instance
-
-      def extra_available_subcommands
-        instance.if_present({}, &:extra_available_subcommands)
-      end
-
-      def stereotype_module
-        instance.application.stereotype.namespace_module
-      end
-
-      def stereotype_name
-        stereotype_module.name
-      end
-
-      private
-
-      def instance_uncached
-        parsed.instance_id.if_present { |v| ::Avm::Registry.instances.detect(v) }
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/instances.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Instances
-  end
-end

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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-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/sub/avm/lib/avm/launcher/context/instance_discovery/root_instance_paths.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require 'ruby-progressbar'
-
-module Avm
-  module Launcher
-    class Context
-      class InstanceDiscovery
-        class RootInstancePaths
-          acts_as_instance_method
-          enable_speaker
-
-          common_constructor :owner
-
-          # @return [Array<Avm::Launcher::Paths::Logical>]
-          def result
-            application_user_local_source_paths.map do |path|
-              ::Avm::Launcher::Paths::Logical.new(owner.context, nil, path.to_path,
-                                                  "/#{path.basename}")
-            end
-          end
-
-          private
-
-          # @param application [Avm::Applications::Base]
-          # @return [Pathname, nil]
-          def application_user_local_source_path(application) # rubocop:disable Metrics/MethodLength
-            if application.user_local_source_path.blank?
-              warn "Application \"#{application}\" does not have a user local source set"
-              nil
-            elsif application.user_local_source_path.directory?
-              infov application,
-                    "user local source found in \"#{application.user_local_source_path}"
-              application.user_local_source_path
-            else
-              warn "Application \"#{application}\"'s local source path is not a directory"
-              nil
-            end
-          end
-
-          # @return [Array<Pathname>]
-          def application_user_local_source_paths
-            ::Avm::Registry.applications.available.sort_by { |a| [a.id] }.map do |application|
-              application_user_local_source_path(application)
-            end.compact_blank.uniq.sort
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Launcher
-    class Context
-      class InstanceDiscovery
-        enable_simple_cache
-
-        # @!method instances
-        #   @return [Array<Avm::Launcher::Instances::Base>]
-
-        # @!method initialize(context)
-        #   @param context [Avm::Launcher::Context]
-        common_constructor :context
-
-        private
-
-        # @return [Array<Avm::Launcher::Instances::Base>]
-        def instances_uncached
-          root_instance_paths.flat_map { |path| path_instances(path, nil) }
-        end
-
-        # @param path [Avm::Launcher::Paths::Logical]
-        # @param parent_instance [Avm::Launcher::Instances::Base]
-        # @return [Array<Avm::Launcher::Instances::Base>]
-        def path_instances(path, parent_instance)
-          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
-            r.concat(children.flat_map { |c| path_instances(c, parent_instance) })
-          end
-        end
-
-        # @param path [Avm::Launcher::Paths::Logical]
-        # @return [Array<Avm::Launcher::Instances::Base>]
-        def on_rescued_path_instances(path)
-          r = []
-          begin
-            yield(r) if path.included?
-          rescue StandardError => e
-            warn("#{path}: #{e}")
-          end
-          r
-        end
-
-        require_sub __FILE__, require_mode: :kernel
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-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/sub/avm/lib/avm/launcher/context/instance_manager/cached_instances.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-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 }.compact_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/sub/avm/lib/avm/launcher/context/instance_manager.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require('yaml')
-
-module Avm
-  module Launcher
-    class Context
-      class InstanceManager
-        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(instances.to_h { |i| [i.logical, i.to_h] })
-          instances
-        end
-
-        def write_cache_file(data)
-          cache_file_path.to_pathname.parent.mkpath
-          ::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/sub/avm/lib/avm/launcher/context/settings.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-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/sub/avm/lib/avm/launcher/context.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/hash/indifferent_access'
-
-require 'eac_cli/speaker'
-
-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 :settings, :cache_root
-      attr_accessor :publish_options, :recache, :instance_manager
-
-      CONFIG_PATH_PREFIX = 'launcher'
-      FS_OBJECT_ID = 'unique'
-
-      def initialize(options = {})
-        @options = options.with_indifferent_access
-        @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 fs_object_id
-        FS_OBJECT_ID
-      end
-
-      def instance(name)
-        instances.find { |i| i.name == name }
-      end
-
-      delegate :instances, to: :@instance_manager
-
-      delegate :pending_instances, to: :@instance_manager
-
-      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
-        fs_cache.path
-      end
-
-      def default_option(key)
-        send("default_#{key}".underscore)
-      end
-
-      def default_settings_file
-        ::File.join(::EacFs::Contexts.config.current.path, '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/sub/avm/lib/avm/launcher/errors/base.rb

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

data/sub/avm/lib/avm/launcher/errors/non_project.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Launcher
-    module Errors
-      class NonProject < ::Avm::Launcher::Errors::Base
-        def initialize(path)
-          super("#{path} is not a project")
-        end
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/launcher/errors.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Launcher
-    module Errors
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-# 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/sub/avm/lib/avm/launcher/instances/base/publishing.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Launcher
-    module Instances
-      module Base
-        module Publishing
-          def publish?(stereotype)
-            publish_by_stereotype?(stereotype) && publish_by_application?(stereotype) &&
-              publish_by_context?(stereotype)
-          end
-
-          # @return [Boolean]
-          def publish_by_application?(stereotype)
-            application.stereotype_publishable?(stereotype)
-          end
-
-          # @return [Boolean]
-          def publish_by_context?(stereotype)
-            filter = ::Avm::Launcher::Context.current.publish_options[:stereotype]
-            filter.blank? || filter == stereotype.name.demodulize
-          end
-
-          # @return [Boolean]
-          def publish_by_stereotype?(stereotype)
-            stereotype.publish_class.present?
-          end
-
-          # @return [Boolean]
-          delegate :publishable?, to: :application
-
-          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 publish_run
-            stereotypes.each do |s|
-              next unless publish?(s)
-
-              infov(name, "publishing #{s.label}")
-              s.publish_class.new(self).run
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-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
-            object.extend ::Avm::Launcher::Instances::Base::Publishing
-            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
-
-        # @return [Avm::Applications::Base]
-        def application
-          @application ||= ::Avm::Registry.applications.detect(project_name)
-        end
-
-        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 project_name
-          ::File.basename(logical)
-        end
-
-        def included?
-          ::Avm::Launcher::Context.current.settings.excluded_projects.exclude?(project_name)
-        end
-
-        def to_h
-          super.to_h.merge(parent: parent&.logical)
-        end
-
-        private
-
-        def options_uncached
-          ::Avm::Launcher::Context.current.settings.instance_settings(self)
-        end
-
-        # @return [Avm::Sources::Base]
-        def source_uncached
-          ::Avm::Registry.sources.detect(real)
-        end
-      end
-    end
-  end
-end

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

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