eac_tools 0.85.1 → 0.86.1

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+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

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/envs/command'
+
+module Avm
+  module Sources
+    class Base
+      module Testing
+        DEFAULT_TEST_COMMANDS = {}.freeze
+        TEST_KEY = 'test'
+        TEST_COMMAND_KEY = "#{TEST_KEY}.command"
+        TEST_COMMANDS_KEY = "#{TEST_KEY}.commands"
+
+        def configured_test_command
+          read_configuration_as_env_command(TEST_COMMAND_KEY)
+        end
+
+        # @return [Hash<String, EacRubyUtils::Envs::Command>, nil]
+        def configured_test_commands
+          configured_value_as_test_commands(configuration_entry(TEST_COMMANDS_KEY).value)
+        end
+
+        # @return [Hash<String, EacRubyUtils::Envs::Command>, nil]
+        def configured_value_as_test_commands(value)
+          return nil if value.nil?
+
+          [::EacRubyUtils::Envs::Command, ::Hash, ::Enumerable].each do |type|
+            next unless value.is_a?(type)
+
+            return send(
+              "configured_#{type.name.demodulize.variableize}_value_as_test_commands",
+              value
+            )
+          end
+
+          raise "Value for test commands should be a Hash or a Enumerable (Actual: #{value})"
+        end
+
+        # @return [Hash<String, EacRubyUtils::Envs::Command>]
+        def default_test_commands
+          DEFAULT_TEST_COMMANDS
+        end
+
+        # @return [Enumerable<EacRubyUtils::Envs::Command>]
+        def test_commands
+          configured_test_commands ||
+            configured_value_as_test_commands(configured_test_command) ||
+            default_test_commands
+        end
+
+        protected
+
+        def configured_command_value_as_test_commands(value)
+          configured_enumerable_value_as_test_commands([value])
+        end
+
+        def configured_enumerable_value_as_test_commands(value)
+          configured_hash_value_as_test_commands(
+            value.each_with_index.to_h { |v, i| ["test_#{i}", v] }
+          )
+        end
+
+        def configured_hash_value_as_test_commands(value)
+          value.to_h { |k, v| [k.to_s.strip, configuration_value_to_env_command(v)] }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Sources
+    class Base
+      module Update
+        # To override in subclasses.
+        def on_sub_updated
+          # Do nothing
+        end
+
+        def update
+          update_self
+          update_subs
+        end
+
+        def update_self
+          scm.commit_if_change(-> { update_self_commit_message }) do
+            update_self_content
+            parent.if_present(&:on_sub_updated)
+          end
+        end
+
+        # Update source self content.
+        #
+        # To override in subclasses.
+        def update_self_content
+          # Do nothing
+        end
+
+        def update_self_commit_message
+          i18n_translate(__method__)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Sources
+    class Base
+      class UpdateSub
+        enable_method_class
+
+        common_constructor :source, :sub
+
+        def result
+          update_version
+          return unless sub.organizational?
+
+          sub.update
+        end
+
+        private
+
+        def update_version
+          base_commit = source.scm.head_commit
+          sub.scm.update
+          on_update_version_commit_change(base_commit) unless base_commit == source.scm.head_commit
+        end
+
+        def on_update_version_commit_change(base_commit)
+          source.on_sub_updated if no_scm_updated?
+          source.scm.reset_and_commit(base_commit, update_version_commit_info)
+        end
+
+        def no_scm_updated?
+          source.scm.head_commit.no_scm_changed_files.any?
+        end
+
+        # @param commit_info [Avm::Scms::CommitInfo]
+        def update_version_commit_info
+          Avm::Scms::CommitInfo.new.message(
+            no_scm_updated? ? update_version_no_scm_message : update_version_scm_message
+          )
+        end
+
+        # @return [String]
+        def update_version_no_scm_message
+          source.i18n_translate(__method__, application_id: sub.application_id,
+                                            path: sub.relative_path, version: sub.version)
+        end
+
+        # @return [String]
+        def update_version_scm_message
+          sub.scm.i18n_translate(__method__)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Sources
+    class Base
+      class UpdateSubs
+        enable_method_class
+
+        common_constructor :source
+
+        def result
+          source.subs.each { |sub| source.update_sub(sub) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'avm/sources/base'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Sources
+    class Base
+      module VersionBump
+        # @return [Avm::Scms::Commit, nil]
+        def version_bump(target_version)
+          scm.commit_if_change(version_bump_commit_message(target_version)) do
+            version_bump_do_changes(target_version)
+            parent.if_present(&:on_sub_updated)
+          end
+        end
+
+        # @return [String]
+        def version_bump_commit_message(target_version)
+          i18n_translate(__method__, version: target_version, __locale: locale)
+        end
+
+        def version_bump_do_changes(_target_version)
+          raise_abstract_method(__METHOD__)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'avm/registry'
+require 'avm/scms/null'
+require 'avm/with/application_stereotype'
+require 'avm/with/extra_subcommands'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Sources
+    class Base
+      require_sub __FILE__, include_modules: true
+      include ::Avm::With::ApplicationStereotype
+      include ::Avm::With::ExtraSubcommands
+      compare_by :path
+      enable_abstract_methods
+      enable_simple_cache
+      enable_listable
+      lists.add_symbol :option, :parent
+      common_constructor :path, :options, default: [{}] do
+        self.path = path.to_pathname.expand_path
+        self.options = ::Avm::Sources::Base.lists.option.hash_keys_validate!(options)
+      end
+
+      abstract_methods :valid?
+
+      # @return [EacRubyUtils::Envs::LocalEnv]
+      def env
+        ::EacRubyUtils::Envs::LocalEnv.new
+      end
+
+      # @return [Pathname]
+      def relative_path
+        return path if parent.blank?
+
+        path.relative_path_from(parent.path)
+      end
+
+      def to_s
+        "#{self.class}[#{path}]"
+      end
+
+      private
+
+      # @return [Avm::Scms::Base]
+      def scm_uncached
+        ::Avm::Registry.scms.detect_optional(path) || ::Avm::Scms::Null.new(path)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Avm
+  module Sources
+    class Configuration < ::EacConfig::OldConfigs
+      module Rubocop
+        RUBOCOP_COMMAND_KEY = 'ruby.rubocop.command'
+        RUBOCOP_GEMFILE_KEY = 'ruby.rubocop.gemfile'
+
+        def rubocop_command
+          read_command(RUBOCOP_COMMAND_KEY)
+        end
+
+        def rubocop_gemfile
+          gemfile_path = read_entry(RUBOCOP_GEMFILE_KEY)
+          return nil if gemfile_path.blank?
+
+          gemfile_path = gemfile_path.to_pathname.expand_path(storage_path.parent)
+          return gemfile_path if gemfile_path.file?
+
+          raise "Gemfile path \"#{gemfile_path}\" does not exist or is not a file"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'eac_config/old_configs'
+require 'eac_ruby_utils/core_ext'
+require 'yaml'
+
+module Avm
+  module Sources
+    class Configuration < ::EacConfig::OldConfigs
+      require_sub __FILE__, include_modules: true
+
+      FILENAMES = %w[.avm.yml .avm.yaml].freeze
+
+      class << self
+        def find_by_path(path)
+          path = ::Pathname.new(path.to_s) unless path.is_a?(::Pathname)
+          internal_find_path(path.expand_path)
+        end
+
+        def find_in_path(path)
+          absolute_pathname = path.to_pathname.expand_path
+          if absolute_pathname.directory?
+            FILENAMES.each do |filename|
+              file = absolute_pathname.join(filename)
+              return new(file) if file.exist?
+            end
+          end
+          nil
+        end
+
+        def temp_instance
+          new(::Tempfile.new(['.avm', '.yaml']))
+        end
+
+        private
+
+        def internal_find_path(absolute_pathname)
+          r = find_in_path(absolute_pathname)
+          return r if r.present?
+
+          internal_find_path(absolute_pathname.dirname) unless absolute_pathname.root?
+        end
+      end
+
+      def initialize(path)
+        super(nil, storage_path: path)
+      end
+
+      # Utility to read a configuration as a [EacRubyUtils::Envs::Command].
+      # @return [EacRubyUtils::Envs::Command]
+      def read_command(key)
+        read_entry(key).if_present do |v|
+          args = v.is_a?(::Enumerable) ? v.map(&:to_s) : ::Shellwords.split(v)
+          ::EacRubyUtils::Envs.local.command(args).chdir(::File.dirname(storage_path))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'eac_cli/core_ext'
+
+module Avm
+  module Sources
+    class Runner
+      runner_with :help, :subcommands do
+        desc 'Root command for sources.'
+        arg_opt '-C', '--path', 'Path to the source.', default: '.'
+        subcommands
+      end
+
+      for_context :optional_source, :source
+
+      def extra_available_subcommands
+        optional_source.if_present({}, &:extra_available_subcommands)
+      end
+
+      def source_banner
+        infov 'Source', source
+      end
+
+      # @return [Pathname]
+      def source_path
+        parsed.path.to_pathname
+      end
+
+      private
+
+      def source_uncached
+        ::Avm::Registry.sources.detect(source_path)
+      end
+
+      def optional_source_uncached
+        ::Avm::Registry.sources.detect_optional(source_path)
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/sources/tests/builder.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'avm/sources/tests/performer'
+require 'avm/sources/tests/single'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Sources
+    module Tests
+      class Builder
+        NO_TEST_TEST_NAME = 'no_test'
+
+        require_sub __FILE__
+        enable_immutable
+
+        immutable_accessor :include_main, :include_subs, type: :boolean
+        immutable_accessor :include_id, type: :array
+        common_constructor :main_source
+
+        def immutable_constructor_args
+          [main_source]
+        end
+
+        # @return [Avm::Sources::Tests::Performer]
+        def performer
+          ::Avm::Sources::Tests::Performer.new(self)
+        end
+
+        def selected_units
+          (select_units_from_subs + select_units_from_main + select_units_from_ids).sort.uniq
+        end
+
+        private
+
+        # @return [Array<Avm::Sources::Tests::Single>]
+        def available_units
+          @available_units ||= ([main_source] + main_source.subs)
+                                 .flat_map { |a_source| create_source_units(a_source) }
+        end
+
+        def available_units_from_main
+          create_units([main_source])
+        end
+
+        def available_units_from_subs
+          create_units(main_source.subs)
+        end
+
+        # @return [Avm::Sources::Tests::Single]
+        def create_source_no_test_unit(source)
+          ::Avm::Sources::Tests::Single.new(self, source, NO_TEST_TEST_NAME,
+                                            source.env.command('true'))
+        end
+
+        # @return [Array<Avm::Sources::Tests::Single>]
+        def create_source_units(source)
+          tests = source.test_commands
+          return create_source_no_test_unit(source) unless tests.any?
+
+          tests.map do |test_name, test_command|
+            ::Avm::Sources::Tests::Single.new(self, source, test_name, test_command)
+          end
+        end
+
+        # @return [Array<Avm::Sources::Tests::Single>]
+        def create_units(sources)
+          sources.flat_map { |a_source| create_source_units(a_source) }
+        end
+
+        # @return [Avm::Sources::Tests::Single]
+        def create_units_by_id(source_id)
+          r = available_units.select { |unit| unit.source.relative_path.to_path == source_id.to_s }
+          return r if r.any?
+
+          raise ::ArgumentError, "Source not found with ID=#{source_id}" \
+                                 "(Available: #{available_units.map(&:id).join(', ')})"
+        end
+
+        # @return [Array<Avm::Sources::Tests::Single>]
+        def select_units_from_ids
+          include_ids.flat_map { |source_id| create_units_by_id(source_id) }
+        end
+
+        # @return [Array<Avm::Sources::Tests::Single>]
+        def select_units_from_main
+          include_main? ? available_units_from_main : []
+        end
+
+        # @return [Array<Avm::Sources::Tests::Single>]
+        def select_units_from_subs
+          include_subs? ? available_units_from_subs : []
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/sources/tests/performer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'avm/sources/tests/result'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Sources
+    module Tests
+      class Performer
+        enable_simple_cache
+
+        common_constructor(:owner)
+
+        def non_failed_units
+          units.reject(&:failed?)
+        end
+
+        def failed_units
+          units.select(&:failed?)
+        end
+
+        # @return [Boolean]
+        def successful?
+          failed_units.none?
+        end
+
+        protected
+
+        def units_uncached
+          owner.selected_units
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/sources/tests/result.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eac_cli/enum'
+
+module Avm
+  module Sources
+    module Tests
+      class Result < ::EacCli::Enum
+        enum :failed, :red
+        enum :nonexistent, :white
+        enum :sucessful, :green
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/sources/tests/single.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'avm/sources/tests/result'
+require 'eac_ruby_utils/core_ext'
+require 'eac_fs/logs'
+
+module Avm
+  module Sources
+    module Tests
+      class Single
+        MAIN_SOURCE_ID = '#main'
+
+        compare_by :order_group, :id
+        enable_simple_cache
+        enable_speaker
+
+        common_constructor :builder, :source, :test_name, :test_command
+
+        delegate :to_s, to: :id
+
+        def failed?
+          result == ::Avm::Sources::Tests::Result::FAILED
+        end
+
+        # @return [String]
+        def id
+          "#{main? ? MAIN_SOURCE_ID : relative_path_from_main_source}##{test_name}"
+        end
+
+        def main?
+          relative_path_from_main_source.to_s == '.'
+        end
+
+        def order_group
+          main? ? 1 : 0
+        end
+
+        # @return [Pathname]
+        def relative_path_from_main_source
+          source.path.relative_path_from(builder.main_source.path)
+        end
+
+        private
+
+        # @return [EacFs::Logs]
+        def logs_uncached
+          ::EacFs::Logs.new.add(:stdout).add(:stderr)
+        end
+
+        # @return [Avm::Sources::Tests::Result]
+        def result_uncached
+          if test_command.blank?
+            ::Avm::Sources::Tests::Result::NONEXISTENT
+          elsif run_test_command
+            ::Avm::Sources::Tests::Result::SUCESSFUL
+          else
+            ::Avm::Sources::Tests::Result::FAILED
+          end
+        end
+
+        def run_test_command
+          execute_command_and_log(test_command)
+        end
+
+        # @return [true, false]
+        def execute_command_and_log(command)
+          r = command.execute
+          logs[:stdout].write(r[:stdout])
+          logs[:stderr].write(r[:stderr])
+          r[:exit_code].zero?
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Avm
+  module Sources
+    class UpdateError < ::RuntimeError
+    end
+  end
+end

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

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