eac_tools 0.93.0 → 0.94.0

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    module Errors
+      require_sub __FILE__
+    end
+  end
+end

data/sub/avm/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/sub/avm/lib/avm/launcher/instances/base/publishing.rb

@@ -0,0 +1,53 @@
+# 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? ? true : 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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/errors/non_project'
+require 'avm/registry'
+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
+            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
+
+        require_sub __FILE__
+
+        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
+      end
+    end
+  end
+end

data/sub/avm/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/sub/avm/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/sub/avm/lib/avm/launcher/instances/settings.rb

@@ -0,0 +1,26 @@
+# 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'
+
+        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
+      end
+    end
+  end
+end

data/sub/{avm-eac_php_base0/lib/avm/eac_php_base0 → avm/lib/avm/launcher}/instances.rb

@@ -3,7 +3,7 @@
 require 'eac_ruby_utils/core_ext'
 
 module Avm
-  module EacPhpBase0
+  module Launcher
     module Instances
       require_sub __FILE__
     end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/paths/real'
+require 'avm/launcher/stereotype'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    module Paths
+      class Logical
+        enable_simple_cache
+
+        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
+
+        common_constructor :context, :parent_path, :real, :logical do
+          self.real = ::Avm::Launcher::Paths::Real.new(real)
+        end
+
+        compare_by :logical, :real
+
+        def to_s
+          logical
+        end
+
+        def to_h
+          { logical: logical, real: real.to_s, parent_path: parent_path&.to_h }
+        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.exclude?(logical)
+        end
+
+        private
+
+        def stereotypes_uncached
+          ::Avm::Launcher::Stereotype.stereotypes.select { |s| s.match?(self) } # rubocop:disable Style/SelectByRegexp
+        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/sub/avm/lib/avm/launcher/paths/real.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Avm
+  module Launcher
+    module Paths
+      class Real < String
+        def initialize(path)
+          raise "Argument path is not a string: \"#{path}\"|#{path.class}" unless path.is_a?(String)
+
+          super
+        end
+
+        def subpath(relative_path)
+          ::Avm::Launcher::Paths::Real.new(::File.expand_path(relative_path, self))
+        end
+
+        def basename
+          ::File.basename(self)
+        end
+
+        def dirname
+          return nil if self == '/'
+
+          self.class.new(::File.dirname(self))
+        end
+
+        def find_file_with_extension(extension)
+          r = find_files_with_extension(extension)
+          return r.first if r.any?
+
+          raise "Extension \"#{extension}\" not found in directory \"#{self}\""
+        end
+
+        def find_files_with_extension(extension)
+          r = []
+          ::Dir.entries(self).each do |i|
+            r << ::File.expand_path(i, self) if i =~ /#{::Regexp.quote(extension)}\z/
+          end
+          r
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    module Paths
+      require_sub __FILE__
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    class Project
+      common_constructor :name, :instances do
+        self.instances = instances.to_a
+      end
+
+      def to_s
+        name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# 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: #{error_message(e)}")
+        end
+
+        # @return [String]
+        def error_message(error)
+          error.to_s + error.cause.if_present('') { |v| " / Caused by: #{error_message(v)}" }
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/publish/check_result.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'active_support/concern' # Missing on "eac/listable"
+require 'active_support/hash_with_indifferent_access'
+require 'eac_ruby_utils/listable'
+
+module Avm
+  module Launcher
+    module Publish
+      class CheckResult
+        include ::EacRubyUtils::Listable
+
+        lists.add_string :status, :updated, :pending, :blocked, :outdated
+
+        lists.status.values.each do |status| # rubocop:disable Style/HashEachMethods
+          singleton_class.define_method status do |message|
+            new(status, message)
+          end
+        end
+
+        class << self
+          def pending_status?(status)
+            [STATUS_PENDING].include?(status)
+          end
+
+          def updated_color
+            'green'
+          end
+
+          def pending_color
+            'yellow'
+          end
+
+          def blocked_color
+            'red'
+          end
+
+          def outdated_color
+            'light_blue'
+          end
+        end
+
+        attr_reader :status, :message
+
+        def initialize(status, message)
+          raise "Status \"#{status}\" not in #{self.class.lists.status.values}" unless
+          self.class.lists.status.values.include?(status)
+
+          @status = status
+          @message = message
+        end
+
+        def to_s
+          message.light_white.send("on_#{background_color}")
+        end
+
+        private
+
+        def background_color
+          self.class.send("#{status}_color")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    module Paths
+      require_sub __FILE__
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'colorized_string'
+
+module Avm
+  module Launcher
+    module Stereotype
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+        end
+
+        def git_stereotypes
+          stereotypes.select { |c| c.name.demodulize.downcase.match('git') }
+        end
+
+        def nogit_stereotypes
+          stereotypes - git_stereotypes
+        end
+
+        def stereotypes
+          ::Avm::Registry.launcher_stereotypes.available
+        end
+      end
+
+      module ClassMethods
+        def label
+          ::ColorizedString.new(stereotype_name).send(color)
+        end
+
+        def stereotype_name
+          name.demodulize
+        end
+
+        {
+          local_project_mixin: ::Module,
+          publish: ::Class,
+          update: ::Class,
+          version_bump: ::Class,
+          warp: ::Class
+        }.each do |name, is_a|
+          define_method "#{name}_#{is_a.name.underscore}" do
+            sub_constant(name.to_s.camelcase, is_a)
+          end
+        end
+
+        private
+
+        def sub_constant(constant_name, is_a)
+          return nil unless const_defined?(constant_name)
+
+          constant = const_get(constant_name)
+          unless is_a.if_present(true) { |v| constant.is_a?(v) }
+            raise("#{constant} is not a #{is_a}")
+          end
+
+          constant
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    require_sub __FILE__
+  end
+end

data/sub/avm/lib/avm/launcher_stereotypes.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module LauncherStereotypes
+    require_sub __FILE__
+  end
+end

data/sub/avm/lib/avm/patches/eac_config/entry_path.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+
+module EacConfig
+  class EntryPath
+    # @return [Symbol]
+    def auto_method_name
+      method_name('auto_', '')
+    end
+
+    # @return [Symbol]
+    def default_method_name
+      method_name('', '_default_value')
+    end
+
+    # @return [Symbol]
+    def get_method_name # rubocop:disable Naming/AccessorMethodName
+      method_name('', '')
+    end
+
+    # @return [Symbol]
+    def get_optional_method_name # rubocop:disable Naming/AccessorMethodName
+      method_name('', '_optional')
+    end
+
+    # @return [Symbol]
+    def inherited_block_method_name
+      method_name('', '_inherited_value_proc')
+    end
+
+    # @return [String]
+    def variableize
+      parts.join('_')
+    end
+
+    private
+
+    # @param before [String]
+    # @param after [String]
+    # @return [Symbol]
+    def method_name(before, after)
+      :"#{before}#{variableize}#{after}"
+    end
+  end
+end