eac_tools 0.105.2 → 0.106.0

data/sub/avm/lib/avm/scms/remote.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Avm
+  module Scms
+    class Remote
+      enable_abstract_methods
+    end
+  end
+end

data/sub/avm/lib/avm/scms.rb

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

data/sub/avm/lib/avm/self/docker_image.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Avm
+  module Self
+    class DockerImage < ::Avm::Docker::Image
+      def stereotype_tag
+        nil
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/self/instance/entry_keys.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Avm
+  module Self
+    class Instance < ::Avm::Instances::Base
+      module EntryKeys
+        DATA_DEFAULT_PATH = 'data.default_path'
+        DOCKER_REGISTRY_NAME = 'docker.registry.name'
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/self/instance.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Avm
+  module Self
+    class Instance < ::Avm::Instances::Base
+      DEFAULT_INSTANCE_ID = 'avm_self'
+
+      class << self
+        def default
+          @default ||= by_id(DEFAULT_INSTANCE_ID)
+        end
+      end
+
+      def docker_image_class
+        ::Avm::Self::DockerImage
+      end
+
+      def docker_registry
+        read_entry(::Avm::Self::Instance::EntryKeys::DOCKER_REGISTRY_NAME)
+      end
+
+      def docker_run_arguments
+        ['-e', "LOCAL_USER_ID=#{::Process.uid}"]
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/source_generators/base.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Avm
+  module SourceGenerators
+    class Base
+      acts_as_abstract
+      enable_settings_provider
+      enable_speaker
+      include ::Avm::With::ApplicationStereotype
+
+      class << self
+        # @return [Avm::SourceGenerators::OptionList]
+        def option_list
+          Avm::SourceGenerators::OptionList.new
+        end
+      end
+
+      OPTION_NAME = 'name'
+      JOBS = [].freeze
+
+      common_constructor :target_path, :options, default: [{}] do
+        self.target_path = target_path.to_pathname
+        self.options = option_list.validate(options)
+      end
+
+      # @return [String]
+      def name
+        options[OPTION_NAME].if_present(target_path.basename.to_path)
+      end
+
+      # @return [Avm::SourceGenerators::OptionList]
+      delegate :option_list, to: :class
+
+      def perform
+        start_banner
+        assert_clear_directory
+        apply_template
+        perform_jobs
+      end
+
+      def assert_clear_directory
+        target_path.mkpath
+        raise "\"#{target_path}\" is not empty" if target_path.children.any?
+      end
+
+      def apply_template
+        root_template.apply(self, target_path)
+      end
+
+      def perform_jobs
+        setting_value(:jobs).each do |job|
+          infom "Generating #{job.humanize}..."
+          send("generate_#{job}")
+        end
+      end
+
+      # @return [void]
+      def start_banner
+        infov 'Target path', target_path
+        infov 'Application name', name
+      end
+
+      # @return [EacTemlates::Modules::Base]
+      def root_template
+        template
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/source_generators/option.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Avm
+  module SourceGenerators
+    class Option
+      common_constructor :name, :description, default: [nil] do
+        self.name = name.to_sym
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/source_generators/option_list.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Avm
+  module SourceGenerators
+    class OptionList
+      enable_immutable
+      immutable_accessor :option, type: :array
+
+      alias immutable_option option
+
+      def option(*args)
+        immutable_option(::Avm::SourceGenerators::Option.new(*args))
+      end
+
+      # @return [Hash<Symbol, String>]
+      def validate(options_hash)
+        options_hash.transform_keys { |k| validate_option(k) }
+      end
+
+      def validate_option(option_name)
+        option_name = option_name.to_sym
+
+        return option_name if options.any? { |option| option.name == option_name }
+
+        raise "No option found with name \"#{option_name}\""
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Avm
+  module SourceGenerators
+    class Runner
+      OPTION_NAME_VALUE_SEPARATOR = ':'
+
+      runner_with :help do
+        arg_opt '-o', '--option', 'Option for generator.', repeat: true, optional: true
+        pos_arg :stereotype_name
+        pos_arg :target_path
+      end
+
+      def run
+        start_banner
+        generate
+      end
+
+      def generate
+        infom 'Generating...'
+        generator.perform
+        success "Source generated in \"#{generator.target_path}\""
+      end
+
+      # @return [String]
+      def help_extra_text
+        help_list_section('Stereotypes', ::Avm::Registry.source_generators.available
+          .map(&:application_stereotype_name))
+      end
+
+      def start_banner
+        infov 'Stereotype', stereotype_name
+        infov 'Target path', target_path
+        infov 'Generator', generator.class
+      end
+
+      def generator_uncached
+        ::Avm::Registry.source_generators
+          .detect_optional(stereotype_name, target_path, options) ||
+          fatal_error("No generator found for stereotype \"#{stereotype_name}\"")
+      end
+
+      delegate :stereotype_name, to: :parsed
+
+      # @return [Hash<String, String>]
+      def options
+        parsed.option.to_h { |v| v.split(OPTION_NAME_VALUE_SEPARATOR) }
+      end
+
+      def target_path
+        parsed.target_path.to_pathname
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/source_generators.rb

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

data/sub/avm/lib/avm/sources/auto_commit/for_file.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Avm
+  module Sources
+    module AutoCommit
+      class ForFile
+        common_constructor :source, :path, :rules
+
+        delegate :run, to: :scm_auto_commit
+
+        # @return [Pathname]
+        def path_for_auto_commit
+          path.relative_path_from(source_for_auto_commit.path)
+        end
+
+        # @return [Avm::Scms::AutoCommit::ForFile]
+        def scm_auto_commit
+          ::Avm::Scms::AutoCommit::ForFile.new(source_for_auto_commit.scm, path_for_auto_commit,
+                                               rules)
+        end
+
+        # @return [Avm::Sources::Base]
+        def source_for_auto_commit
+          source.sub_for_path(path) || source
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/sources/auto_commit.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Avm
+  module Sources
+    module AutoCommit
+    end
+  end
+end

data/sub/avm/lib/avm/sources/base/application.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Avm
+  module Sources
+    class Base
+      module Application
+        APPLICATION_NAME_KEY = 'application'
+
+        # @return [Avm::Applications::Base]
+        def application
+          @application ||= ::Avm::Applications::Base.new(application_id)
+        end
+
+        # @return [String]
+        def application_id
+          application_id_by_configuration || application_id_by_directory
+        end
+
+        # @return [String, nil]
+        def application_id_by_configuration
+          configuration.entry(APPLICATION_NAME_KEY).value
+        end
+
+        # @return [String]
+        def application_id_by_directory
+          path.basename.to_path.gsub(::EacConfig::EntryPath::PART_SEPARATOR, '-')
+            .gsub(/\A-+/, '').gsub(/-+\z/, '')
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/sources/base/configuration.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module Avm
+  module Sources
+    class Base
+      module Configuration
+        PARENT_CONFIGURATION_SUFFIX = %w[subs at].freeze
+        CONFIGURATION_FILENAMES = %w[.avm.yml .avm.yaml].freeze
+
+        # @return [EacConfig::NodeEntry]
+        def configuration_entry(*entry_args)
+          parent_configuration.if_present do |v|
+            parent_entry = v.entry(*entry_args)
+            return parent_entry if parent_entry.found?
+          end
+
+          configuration.entry(*entry_args)
+        end
+
+        # The possible absolute paths for configuration files.
+        #
+        # @return [Array<Pathname>]
+        def configuration_paths
+          CONFIGURATION_FILENAMES.map { |filename| path.join(filename) }
+        end
+
+        # @return [EacRubyUtils::Envs::Command, nil]
+        def configuration_value_to_env_command(value)
+          return value if value.is_a?(::EacRubyUtils::Envs::Command)
+
+          configuration_value_to_shell_words(value).if_present { |v| env.command(v).chdir(path) }
+        end
+
+        # @return [Array<String>, nil]
+        def configuration_value_to_shell_words(value)
+          return nil if value.blank?
+
+          value.is_a?(::Enumerable) ? value.map(&:to_s) : ::Shellwords.split(value.to_s)
+        end
+
+        # @return [Array<String>, nil]
+        def read_configuration_as_shell_words(key)
+          configuration_value_to_shell_words(configuration_entry(key).value)
+        end
+
+        # Utility to read a configuration as a [EacRubyUtils::Envs::Command].
+        # @return [EacRubyUtils::Envs::Command]
+        def read_configuration_as_env_command(key)
+          configuration_value_to_env_command(configuration_entry(key).value)
+        end
+
+        private
+
+        # @return [EacConfig::YamlFileNode]
+        def configuration_uncached
+          configuration_paths.each do |config_path|
+            configuration_with_filename(config_path, true)
+          end
+          configuration_with_filename(configuration_paths.first, false)
+        end
+
+        # @return [Enumerable<String>]
+        def parent_configuration_prefix
+          PARENT_CONFIGURATION_SUFFIX + [relative_path.to_path.gsub(/\A\.+|\.+\z/, '')]
+        end
+
+        # @return [EacConfig::PrefixedPathNode]
+        def parent_configuration_uncached
+          parent.if_present { |v| v.configuration.with_prefix(parent_configuration_prefix) }
+        end
+
+        # @return [EacConfig::YamlFileNode, nil]
+        def configuration_with_filename(config_path, needs_exist)
+          return ::EacConfig::YamlFileNode.new(config_path) if !needs_exist || config_path.exist?
+
+          nil
+        end
+
+        # @return [Avm::Sources::Configuration]
+        def old_configuration_uncached
+          ::Avm::Sources::Configuration.find_in_path(path) ||
+            ::Avm::Sources::Configuration.temp_instance
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/sources/base/instance.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Avm
+  module Sources
+    class Base
+      module Instance
+        def instance
+          application.local_instance
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/sources/base/locale.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'i18n'
+
+module Avm
+  module Sources
+    class Base
+      module Locale
+        LOCALE_KEY = 'locale'
+
+        def locale
+          configured_locale || default_locale
+        end
+
+        def configured_locale
+          configuration_entry(LOCALE_KEY).value
+        end
+
+        delegate :default_locale, to: :'::I18n'
+
+        # @param entry_suffix [String]
+        # @param values [Hash]
+        # @return [String]
+        def i18n_translate(entry_suffix, values = {})
+          self.class.i18n_translate(entry_suffix, values.merge(__locale: locale))
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/sources/base/organizational.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Avm
+  module Sources
+    class Base
+      module Organizational
+        DEFAULT_ORGANIZATIONAL = false
+        ORGANIZATIONAL_KEY = 'organizational'
+
+        # @return [Boolean]
+        def organizational?
+          if organizational_entry.found?
+            organizational_entry.value.to_bool
+          else
+            default_organizational
+          end
+        end
+
+        def organizational_entry
+          configuration.entry(ORGANIZATIONAL_KEY)
+        end
+
+        # @return [Boolean]
+        def default_organizational
+          DEFAULT_ORGANIZATIONAL
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/sources/base/parent.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Avm
+  module Sources
+    class Base
+      module Parent
+        # @return [Avm::Sources::Base]
+        def parent_by_option
+          options[OPTION_PARENT]
+        end
+
+        # @return [Avm::Sources::Base]
+        def parent_by_search
+          ::Avm::Registry.sources.detect_by_path_optional(path.parent)
+        end
+
+        private
+
+        # @return [Avm::Sources::Base]
+        def parent_uncached
+          parent_by_option || parent_by_search
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/sources/base/stereotype.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Avm
+  module Sources
+    class Base
+      module Stereotype
+        STEREOTYPE_NAME_KEY = 'stereotype'
+
+        # @return [String, nil]
+        def stereotype_name_by_configuration
+          configuration.entry(STEREOTYPE_NAME_KEY).value
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/sources/base/sub/remove.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Avm
+  module Sources
+    class Base
+      class Sub
+        class Remove
+          acts_as_instance_method
+
+          # !method initialize(sub)
+          # @param sub [Avm::Sources::Base::Sub]
+          common_constructor :sub
+          delegate :source, to: :sub
+
+          # @return [void]
+          def result
+            source.scm.commit_if_change(commit_message) { do_changes }
+          end
+
+          private
+
+          # @return [String]
+          def commit_message
+            sub.i18n_translate(:remove_commit_message, sub_path: sub.sub_path)
+          end
+
+          # @return [void]
+          def do_changes
+            ::FileUtils.rm_rf(sub.absolute_path)
+            source.on_sub_updated
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/sources/base/sub.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Avm
+  module Sources
+    class Base
+      class Sub
+        # !method initialize(source, sub_path)
+        # @param source [Avm::Sources::Base]
+        # @param sub_path [Pathname]
+        common_constructor :source, :sub_path do
+          self.sub_path = sub_path.to_pathname.cleanpath
+        end
+
+        # @return [Pathname]
+        def absolute_path
+          sub_path.expand_path(source.path)
+        end
+
+        require_sub __FILE__, require_mode: :kernel
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/sources/base/subs.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Avm
+  module Sources
+    class Base
+      module Subs
+        CONFIGURATION_SUBS_EXCLUDE_PATHS_KEY = 'subs.exclude_path'
+        CONFIGURATION_SUBS_INCLUDE_PATHS_KEY = 'subs.include_path'
+        SUBS_EXCLUDE_PATHS_DEFAULT = [].freeze
+        SUBS_INCLUDE_PATHS_DEFAULT = ['sub/*'].freeze
+
+        # @return [Avm::Sources::Base, nil]
+        def sub_for_path(path)
+          subs.lazy.map { |sub| path.expand_path.child_of?(sub.path) ? sub : nil }.find(&:present?)
+        end
+
+        # @param sub_path [Pathname]
+        # @return [Avm::Sources::Base::Sub]
+        def sub(sub_path)
+          ::Avm::Sources::Base::Sub.new(self, sub_path)
+        end
+
+        # @return [Enumerable<Avm::Sources::Base>]
+        def subs
+          subs_paths_to_search
+            .map { |sub_path| ::Avm::Registry.sources.detect_optional(sub_path, parent: self) }
+            .compact_blank
+            .sort_by { |sub| [sub.path] }
+        end
+
+        def subs_paths_to_search
+          subs_include_paths.flat_map do |subs_include_path|
+            ::Pathname.glob(path.join(subs_include_path)).reject do |sub_path|
+              subs_exclude_paths.any? do |subs_exclude_path|
+                sub_path.fnmatch?(path.join(subs_exclude_path).to_path)
+              end
+            end
+          end
+        end
+
+        %i[include exclude].each do |type|
+          %i[path paths configured_paths default_paths].each do |method_suffix|
+            obj_method_name = "subs_#{type}_path_obj"
+
+            define_method "subs_#{type}_#{method_suffix}" do
+              send(obj_method_name).send(method_suffix)
+            end
+
+            define_method "#{obj_method_name}_uncached" do
+              ::Avm::Sources::Base::SubsPaths.new(
+                self,
+                self.class.const_get("CONFIGURATION_SUBS_#{type}_PATHS_KEY".upcase),
+                self.class.const_get("SUBS_#{type}_PATHS_DEFAULT".upcase)
+              )
+            end
+
+            private "#{obj_method_name}_uncached" # rubocop:disable Style/AccessModifierDeclarations
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/sources/base/subs_paths.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Avm
+  module Sources
+    class Base
+      class SubsPaths
+        SUBS_PATH_SEPARATOR = ':'
+
+        common_constructor :source, :configuration_key, :default_paths
+
+        # @return [String]
+        def path
+          paths.join(SUBS_PATH_SEPARATOR)
+        end
+
+        # @return [Array<String>]
+        def paths
+          configured_paths || default_paths
+        end
+
+        # @return [Array<String>]
+        def configured_paths
+          source.configuration_entry(configuration_key).value.if_present do |v|
+            v.split(SUBS_PATH_SEPARATOR)
+          end
+        end
+      end
+    end
+  end
+end