eac_tools 0.111.1 → 0.112.0

data/sub/avm-tools/lib/avm/tools/runner/source/sub.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Avm
+  module Tools
+    class Runner
+      class Source < ::Avm::Sources::Runner
+        class Sub
+          runner_with :help, :subcommands do
+            pos_arg :sub_path
+            subcommands
+          end
+          for_context :source_sub
+
+          private
+
+          # !method source_sub
+          # @return [Avm::Sources::Base::Sub]
+          def source_sub_uncached
+            source.sub(parsed.sub_path)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner/source/subs.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Avm
+  module Tools
+    class Runner
+      class Source < ::Avm::Sources::Runner
+        class Subs
+          PADDING = '  '
+
+          runner_with :help, :output do
+            desc 'Output source\'s subs.'
+            bool_opt '-i', '--info'
+            bool_opt '-R', '--recursive'
+            bool_opt '-t', '--tree'
+          end
+
+          def run
+            start_banner
+            run_output
+          end
+
+          def start_banner
+            infov 'Include PATH', runner_context.call(:subject).subs_include_path
+            infov 'Exclude PATH', runner_context.call(:subject).subs_exclude_path
+            infov 'Count', runner_context.call(:subject).subs.count
+          end
+
+          def output_content
+            b = []
+            runner_context.call(:subject).subs.each do |sub|
+              b += sub_output_content_lines(sub, 0)
+            end
+            b.map { |line| "#{line}\n" }.join
+          end
+
+          def sub_info_label(sub)
+            return '' unless parsed.info?
+
+            ' [' + { # rubocop:disable Style/StringConcatenation
+              'CLASS' => sub.class.name,
+              'SCM' => sub.scm.class.name
+            }.map { |k, v| "#{k}: #{v}" }.join(', ') + ']'
+          end
+
+          def sub_label(sub, level)
+            sub_self_label(sub, level) + sub_info_label(sub)
+          end
+
+          def sub_self_label(sub, level)
+            if parsed.tree?
+              (PADDING * level) + sub.relative_path.to_s
+            else
+              sub.path.relative_path_from(runner_context.call(:subject).path).to_s
+            end
+          end
+
+          def sub_output_content_lines(sub, level)
+            [sub_label(sub, level)] + sub_subs_output_content_lines(sub, level)
+          end
+
+          def sub_subs_output_content_lines(sub, level)
+            return [] unless parsed.recursive?
+
+            sub.subs.flat_map { |sub_sub| sub_output_content_lines(sub_sub, level + 1) }
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner/source/test.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Avm
+  module Tools
+    class Runner
+      class Source < ::Avm::Sources::Runner
+        class Test
+          runner_with :help do
+            desc 'Test local project.'
+            bool_opt '-a', '--all', 'Same as "--self --subs".'
+            bool_opt '-f', '--fail-fast', 'Abort after first failure.'
+            bool_opt '-m', '--main', 'Test main source.'
+            bool_opt '-s', '--subs', 'Test subs\' sources.'
+            pos_arg :source_id, repeat: true, optional: true
+          end
+
+          def run
+            reset_tested_units
+            start_banner
+            show_units_results
+            final_result
+          end
+
+          private
+
+          attr_accessor :tested_units
+
+          def failed_units
+            tested_units.select(&:failed?)
+          end
+
+          def final_result
+            if failed_units.any?
+              failed_units.each do |unit|
+                infov '  * Source', unit
+                info unit.logs.truncate_all
+              end
+              fatal_error 'Some test did not pass'
+            else
+              success 'None test failed'
+            end
+          end
+
+          def include_main?
+            parsed.main? || parsed.all?
+          end
+
+          def include_subs?
+            parsed.subs? || parsed.all?
+          end
+
+          def reset_tested_units
+            self.tested_units = []
+          end
+
+          def show_units_results
+            test_performer.units.each do |unit|
+              infov unit, unit_result(unit)
+              tested_units << unit
+              break if unit.failed? && parsed.fail_fast?
+            end
+          end
+
+          def start_banner
+            runner_context.call(:source_banner)
+            infov 'Selected units', test_performer.units.count
+          end
+
+          def test_builder
+            r = ::Avm::Sources::Tests::Builder.new(runner_context.call(:subject))
+                  .include_main(include_main?)
+                  .include_subs(include_subs?)
+            parsed.source_id.inject(r) { |a, e| a.include_id(e) }
+          end
+
+          def test_performer_uncached
+            test_builder.performer
+          end
+
+          def unit_result(unit)
+            (
+              [unit.result.to_label] +
+                %i[stdout stderr].map { |label| "#{label.to_s.upcase}: #{unit.logs[label]}" }
+            ).join(' | '.blue)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner/source/update.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Avm
+  module Tools
+    class Runner
+      class Source < ::Avm::Sources::Runner
+        class Update
+          runner_with :help do
+            desc 'Update local project.'
+          end
+
+          def run
+            infov 'Path', runner_context.call(:subject).path
+            runner_context.call(:subject).update
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner/source/version_bump.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Avm
+  module Tools
+    class Runner
+      class Source < ::Avm::Sources::Runner
+        class VersionBump
+          runner_with :help, :confirmation do
+            desc 'Bump version of a local project.'
+            arg_opt '-n', '--new', 'Set new version.'
+            arg_opt '-s', '--segment', 'Increment de <segment>-th segment (Left-most is 0)'
+            bool_opt '-M', '--major', 'Same as --segment=0.'
+            bool_opt '-m', '--minor', 'Same as --segment=1.'
+            bool_opt '-p', '--patch', 'Same as --segment=2.'
+          end
+
+          def run
+            start_banner
+            version_changed? ? run_version_changed : run_version_unchanged
+          end
+
+          def run_version_changed
+            infom 'Version changed'
+            if confirm?
+              runner_context.call(:subject).version_bump(target_version)
+              success 'Bumped'
+            else
+              fatal_error 'Bump unconfirmed'
+            end
+          end
+
+          def run_version_unchanged
+            success 'Version unchanged'
+          end
+
+          def start_banner
+            infov 'Instance', runner_context.call(:subject)
+            infov 'Current version', current_version.if_present('-')
+            infov 'Target version', target_version.if_present('-')
+          end
+
+          def current_version_uncached
+            runner_context.call(:subject).version
+          end
+
+          def target_version_uncached
+            current_version.if_present do |r|
+              %w[new segment major minor patch].inject(r) do |a, e|
+                option_value = parsed[e]
+                next a if option_value.blank?
+
+                send("target_version_from_#{e}", a, option_value)
+              end
+            end
+          end
+
+          def target_version_from_new(_current, option_value)
+            ::Avm::VersionNumber.new(option_value)
+          end
+
+          def target_version_from_segment(current, option_value)
+            current.increment_segment(option_value.to_i)
+          end
+
+          %w[major minor patch].each_with_index do |segment, segment_index|
+            define_method "target_version_from_#{segment}" do |current, _option_value|
+              target_version_from_segment(current, segment_index)
+            end
+          end
+
+          def version_changed?
+            target_version != current_version
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner/source.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Avm
+  module Tools
+    class Runner
+      class Source < ::Avm::Sources::Runner
+        def subject
+          source
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner/source_generate.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Avm
+  module Tools
+    class Runner
+      class SourceGenerate < ::Avm::SourceGenerators::Runner
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Avm
+  module Tools
+    class Runner
+      include ::EacRubyBase0::Runner
+
+      runner_definition do
+        desc 'Tools for AVM.'
+      end
+
+      delegate :application, to: :'::Avm::Tools::Self'
+
+      def extra_available_subcommands
+        ::Avm::Registry.runners.registered_modules.index_by(&:command_argument)
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner_with/include_exclude.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Avm
+  module Tools
+    module RunnerWith
+      module IncludeExclude
+        common_concern do
+          include ::EacCli::Runner
+
+          runner_definition do
+            arg_opt '-I', '--include', repeat: true
+            arg_opt '-E', '--exclude', repeat: true
+          end
+        end
+
+        delegate :include, :exclude, to: :parsed
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner_with/instance_data_clear.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Avm
+  module Tools
+    module RunnerWith
+      module InstanceDataClear
+        common_concern do
+          enable_simple_cache
+          include ::Avm::Tools::RunnerWith::InstanceDataPerformer
+        end
+
+        # @return [Class]
+        def data_performer_class
+          ::Avm::Data::Clearer
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner_with/instance_data_dump.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Avm
+  module Tools
+    module RunnerWith
+      module InstanceDataDump
+        common_concern do
+          enable_simple_cache
+          runner_definition do
+            bool_opt '-w', '--rewrite', 'Forces dump overwrite.'
+            pos_arg :dump_path, optional: true
+          end
+
+          set_callback :run, :after do
+            success("Dump path: \"#{dump_path}\"")
+            dump_path
+          end
+        end
+
+        include ::Avm::Tools::RunnerWith::InstanceDataPerformer
+
+        DUMP_EXPIRE_TIME = 1.day
+        NO_DUMP_MESSAGE = 'Dump "%s" already exist and rewrite options was no setted nor ' \
+                          'dump was expired.'
+
+        # @return [Class]
+        def data_performer_class
+          ::Avm::Data::Dumper
+        end
+
+        # @return [String]
+        def help_extra_text
+          "Default dump path: \"#{default_dump_path}\""
+        end
+
+        private
+
+        # @return [Avm::Data::Dumper]
+        def data_performer_uncached
+          r = super.overwrite(parsed.rewrite?)
+          parsed.dump_path.if_present(r) { |v| r.target_path(v.to_pathname) }
+        end
+
+        # @return [Pathname]
+        def dump_path
+          data_performer.target_path
+        end
+
+        def default_dump_path
+          data_performer.default_dump_path
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner_with/instance_data_load.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Avm
+  module Tools
+    module RunnerWith
+      module InstanceDataLoad
+        common_concern do
+          enable_simple_cache
+
+          runner_definition do
+            arg_opt '-S', '--source-instance', 'Informa a instância a ser extraída o dump.'
+            bool_opt '-w', '--rewrite'
+            pos_arg :dump_path, optional: true
+          end
+
+          set_callback :run, :after do
+            success("Dump loaded from \"#{dump_path}\"")
+          end
+        end
+
+        include ::Avm::Tools::RunnerWith::InstanceDataPerformer
+
+        # @return [Class]
+        def data_performer_class
+          ::Avm::Data::Loader
+        end
+
+        private
+
+        # @return [Avm::Data::Loader]
+        def data_performer_uncached
+          super.source_path(dump_path)
+        end
+
+        # @return [Pathname]
+        def dump_path_uncached
+          return parsed.dump_path.to_pathname if parsed.dump_path.present?
+          return source_instance_dump_path if parsed.source_instance.present?
+
+          fatal_error "Dump path not set (Options: #{parsed})"
+        end
+
+        # @return [Avm::Instances::Base]
+        def source_instance
+          runner_context.call(:instance).class.by_id(parsed.source_instance)
+        end
+
+        # @return [Avm::Data::Dumper]
+        def source_instance_dumper
+          data_performer_set_includes_excludes(
+            ::Avm::Data::Dumper.new(source_instance_data_owner).overwrite(parsed.rewrite?)
+          )
+        end
+
+        # @return [Pathname]
+        def source_instance_dump_path
+          r = source_instance_dumper
+          r.perform
+          r.target_path
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner_with/instance_data_performer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Avm
+  module Tools
+    module RunnerWith
+      module InstanceDataPerformer
+        acts_as_abstract :data_performer_class
+        common_concern do
+          enable_simple_cache
+          include ::EacCli::Runner
+        end
+
+        def run
+          if data_performer.performable?
+            data_performer.perform
+          else
+            fatal_error("Cannot perform: #{data_performer.cannot_perform_reason}")
+          end
+        end
+
+        private
+
+        # @return [Avm::Data::Performer]
+        def data_performer_uncached
+          data_performer_set_includes_excludes(data_performer_class.new(data_owner))
+        end
+
+        # @return [Avm::Data::Performer]
+        def data_performer_set_includes_excludes(data_performer)
+          %i[include exclude].inject(data_performer) do |a1, e1|
+            if_respond(e1, []).inject(a1) { |a2, e2| a2.send(e1, e2) }
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/self.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Avm
+  module Tools
+    module Self
+      class << self
+        def application
+          @application ||= ::EacRubyBase0::Application.new(root.to_path)
+        end
+
+        def root
+          ::Pathname.new('../../..').expand_path(__dir__)
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Avm
+  module Tools
+    VERSION = '0.164.0'
+  end
+end

data/sub/avm-tools/lib/avm/tools.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+EacRubyUtils::RootModuleSetup.perform __FILE__ do
+  ignore 'core_ext'
+end
+
+module Avm
+  module Tools
+  end
+end
+
+require 'avm'
+require 'eac_ruby_base0'
+
+require 'avm/tools/core_ext'

data/sub/avm-tools/spec/lib/avm/tools/runner/files/rotate_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require 'fileutils'
+
+class StubClock
+  attr_reader :current
+
+  def initialize(year, month, day)
+    @current = ::Time.new(year, month, day)
+  end
+
+  def tick
+    @current += 1.day
+    @current
+  end
+end
+
+RSpec.describe Avm::Tools::Runner::Files::Rotate do
+  let(:workdir) { Dir.mktmpdir }
+  let(:source_basename) { 'myfile.tar.gz' }
+  let(:source_path) { File.join(workdir, source_basename) }
+
+  before do
+    FileUtils.touch(source_path)
+  end
+
+  it { expect(File.exist?(source_path)).to be(true) }
+
+  context 'when run' do
+    let(:files_with_prefix) { Dir["#{workdir}/myfile_*.tar.gz"] }
+
+    before do
+      Avm::Tools::Runner.run(argv: ['files', 'rotate', source_path])
+    end
+
+    it { expect(File.exist?(source_path)).to be(false) }
+    it { expect(files_with_prefix.count).to eq(1) }
+  end
+
+  describe 'space limit' do
+    let(:tempdir) { Dir.mktmpdir }
+    let(:clock) { StubClock.new(2000, 1, 1) }
+
+    it 'limit space used by rotated files' do # rubocop:disable RSpec/NoExpectationExample
+      file1 = create_and_rotate_stub_file([], [])
+      file2 = create_and_rotate_stub_file([file1], [])
+      file3 = create_and_rotate_stub_file([file2], [file1])
+      create_and_rotate_stub_file([file3], [file1, file2])
+    end
+
+    def create_and_rotate_stub_file(expect_exist, expect_not_exist)
+      rotate_runner = described_class.create(argv: [create_stub_file, '--space-limit=32'])
+      rotate_runner.run
+      test_files(rotate_runner.rotate, expect_exist, expect_not_exist)
+      rotate_runner.rotate.target_path
+    end
+
+    def test_files(rotate, expect_exist, expect_not_exist)
+      (expect_exist + [rotate.target_path]).each { |path| expect(File).to exist(path) }
+      expect_not_exist.each { |path| expect(File).not_to exist(path) }
+    end
+
+    def create_stub_file
+      stub_path = File.join(tempdir, 'stub.ext')
+      File.write(stub_path, 'A' * 16)
+      FileUtils.touch(stub_path, mtime: clock.tick)
+      stub_path
+    end
+  end
+end

data/sub/avm-tools/spec/lib/avm/tools/runner/launcher_stereotypes/list_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.describe Avm::Tools::Runner::LauncherStereotypes::List do
+  def avm_tools_runner_args_prefix
+    %w[launcher-stereotypes list]
+  end
+
+  it do
+    expect { avm_tools_runner_run }.not_to raise_error
+  end
+
+  it do
+    expect { avm_tools_runner_run('--deprecated') }.not_to raise_error
+  end
+end