eac_tools 0.1.2 → 0.2.2

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'avm/eac_writings_base0/project'
+require 'eac_cli/core_ext'
+
+module Avm
+  module Tools
+    class Runner
+      class AppSrc
+        class EacWritingsBase0
+          require_sub __FILE__
+          enable_simple_cache
+
+          runner_with :help, :subcommands do
+            desc 'EacWritingsBase0 utitilies for local projects.'
+            subcommands
+          end
+
+          def project_banner
+            infov 'Project', project.name
+            infov 'Path', project.root
+          end
+
+          private
+
+          def project_uncached
+            ::Avm::EacWritingsBase0::Project.new(runner_context.call(:instance_path))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'avm/tools/core_ext'
+
+module Avm
+  module Tools
+    class Runner
+      class AppSrc
+        class Info
+          runner_with :help do
+            desc 'Show information about local project instance.'
+          end
+
+          def run
+            show_instance
+            show_source
+          end
+
+          private
+
+          def show_instance
+            infov 'Path', instance.path
+            infov 'Launcher stereotypes', instance.stereotypes.map(&:label).join(', ')
+          end
+
+          def show_source
+            infov 'Stereotype', runner_context.call(:subject).class
+            infov 'SCM', runner_context.call(:subject).scm
+          end
+
+          def instance
+            runner_context.call(:instance)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner/app_src/issue/complete.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'avm/tools/core_ext'
+require 'avm/git/issue/complete'
+
+module Avm
+  module Tools
+    class Runner
+      class AppSrc
+        class Issue
+          class Complete
+            runner_with :confirmation, :help do
+              desc 'Closes a issue in a Git repository.'
+              bool_opt '-f', '--uncomplete-unfail', 'Do not exit with error if issue is not' \
+                ' completed or is invalid.'
+              arg_opt '-s', '--skip-validations', 'Does not validate conditions on <validations>' \
+                ' (Comma separated value).'
+            end
+
+            def run
+              return unless run_validate
+              return unless run_complete
+
+              success('Done!')
+            end
+
+            def help_extra_text
+              "Validations:\n#{doc_validations_list}"
+            end
+
+            def run_validate
+              complete.start_banner
+              return true if complete.valid?
+
+              uncomplete_message('Some validation did not pass')
+            end
+
+            def run_complete
+              return complete.run if confirm?('Confirm issue completion?')
+
+              uncomplete_message('Issue was not completed')
+            end
+
+            private
+
+            def complete_uncached
+              ::Avm::Git::Issue::Complete.new(git_complete_issue_options)
+            end
+
+            def skip_validations
+              parsed.skip_validations.to_s.split(',').map(&:strip).reject(&:blank?)
+            end
+
+            def git_complete_issue_options
+              { dir: runner_context.call(:subject).path.to_path,
+                skip_validations: skip_validations }
+            end
+
+            def doc_validations_list
+              ::Avm::Git::Issue::Complete::VALIDATIONS.keys.map { |k| "  * #{k}" }.join("\n")
+            end
+
+            def uncomplete_unfail?
+              parsed.uncomplete_unfail?
+            end
+
+            def uncomplete_message(message)
+              if uncomplete_unfail?
+                warn(message)
+              else
+                fatal_error(message)
+              end
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner/app_src/issue/deliver.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'avm/tools/core_ext'
+require 'avm/git/issue/deliver'
+
+module Avm
+  module Tools
+    class Runner
+      class AppSrc
+        class Issue
+          class Deliver
+            runner_with :confirmation, :help do
+              desc 'Deliver a issue in a Git repository.'
+            end
+
+            def run
+              deliver.start_banner
+              if confirm?('Confirm issue delivery?')
+                deliver.run
+              else
+                fatal_error 'Issue undelivered'
+              end
+            end
+
+            private
+
+            def deliver_uncached
+              ::Avm::Git::Issue::Deliver.new(runner_context.call(:subject).scm.git_repo)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'avm/tools/core_ext'
+
+module Avm
+  module Tools
+    class Runner
+      class AppSrc
+        class Issue
+          require_sub __FILE__
+          runner_with :help, :subcommands do
+            desc 'Issue operations within Git.'
+            subcommands
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner/app_src/ruby/bundler/gemfile_lock/git.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_base0/core_ext'
+
+module Avm
+  module Tools
+    class Runner
+      class AppSrc
+        class Ruby
+          class Bundler
+            class GemfileLock
+              module Git
+                private
+
+                def git_continue
+                  return unless check_capability(__method__, :git_repo, :continue)
+
+                  infom "Adding \"#{gemfile_lock}\"..."
+                  instance.git_repo.command('add', gemfile_lock).execute!
+                  if rebase_conflict?
+                    git_continue_run('rebase')
+                  elsif cherry_conflict?
+                    git_continue_run('cherry-pick')
+                  else
+                    raise 'Unknown how to continue'
+                  end
+                end
+
+                def git_continue_run(command)
+                  infom "\"#{command}\" --continue..."
+                  cmd = instance.git_repo.command(command, '--continue')
+                          .envvar('GIT_EDITOR', 'true')
+                  return unless !cmd.system && !conflict?
+
+                  fatal_error "\"#{cmd}\" failed and there is no conflict"
+                end
+
+                def git_reset_checkout
+                  return unless check_capability(__method__, :git_repo, nil)
+
+                  git_reset_gemfile_lock
+                  git_checkout_gemfile_lock
+                end
+
+                def git_checkout_gemfile_lock
+                  infom 'Checkouting...'
+                  instance.git_repo.command('checkout', '--', gemfile_lock).system!
+                end
+
+                def git_reset_gemfile_lock
+                  infom 'Reseting...'
+                  instance.git_repo.command('reset', gemfile_lock).system! if
+                  ::File.exist?(gemfile_lock)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner/app_src/ruby/bundler/gemfile_lock.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_base0/core_ext'
+
+module Avm
+  module Tools
+    class Runner
+      class AppSrc
+        class Ruby
+          class Bundler
+            class GemfileLock
+              require_sub __FILE__, include_modules: true
+              runner_with :help do
+                desc 'Manipulage a "Gemfile.lock" file.'
+                bool_opt '-c', '--continue', 'Continue Git rebase/cherry-pick.'
+                bool_opt '-i', '--install', 'Run "bundle install".'
+                bool_opt '-u', '--update', 'Run "bundle update".'
+                bool_opt '-r', '--recursive', 'Run until Git rebase/cherry-pick is finished.'
+                bool_opt '-a', '--all', 'Same as "-cirud".'
+                bool_opt '-d', '--delete', 'Delete Gemfile.lock'
+              end
+
+              def run
+                loop do
+                  git_reset_checkout
+                  delete_gemfile_lock
+                  bundle_update
+                  bundle_install
+                  git_continue
+                  break if complete?
+                end
+              end
+
+              private
+
+              def complete?
+                !option_or_all?(:recursive) || !conflict?
+              end
+
+              def delete_gemfile_lock
+                return unless check_capability(__method__, nil, :delete)
+
+                ::FileUtils.rm_f(gemfile_lock)
+              end
+
+              def rebasing?
+                instance.git_repo.root_path.join('.git', 'rebase-merge').exist?
+              end
+
+              def bundle_install
+                return unless check_capability(__method__, :ruby_gem, :install)
+
+                infom '"bundle install"...'
+                bundle_run('install')
+              end
+
+              def bundle_update
+                return unless check_capability(__method__, :ruby_gem, :update)
+
+                infom '"bundle update"...'
+                bundle_run('update')
+              end
+
+              def gemfile_lock
+                'Gemfile.lock'
+              end
+
+              def bundle_run(*args)
+                instance.ruby_gem.bundle(*args).system!
+              end
+
+              def conflict?
+                rebase_conflict? || cherry_conflict?
+              end
+
+              def rebase_conflict?
+                instance.git_repo.root_path.join('.git', 'REBASE_HEAD').exist?
+              end
+
+              def cherry_conflict?
+                instance.git_repo.root_path.join('.git', 'CHERRY_PICK_HEAD').exist?
+              end
+
+              def option_or_all?(option)
+                parsed[option] || parsed.all?
+              end
+
+              def instance
+                runner_context.call(:instance)
+              end
+
+              def check_capability(caller, capability, option)
+                return false unless option.blank? || option_or_all?(option)
+                return true if capability.if_present(true) { |v| instance.respond_to?(v) }
+
+                warn "Cannot run #{caller}: instance has no capability \"#{capability}\""
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner/app_src/ruby/bundler.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_base0/core_ext'
+
+module Avm
+  module Tools
+    class Runner
+      class AppSrc
+        class Ruby
+          class Bundler
+            require_sub __FILE__
+            runner_with :help, :subcommands do
+              desc 'Ruby\'s bundler utitilies for local projects.'
+              subcommands
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'eac_cli/core_ext'
+
+module Avm
+  module Tools
+    class Runner
+      class AppSrc
+        class Ruby
+          require_sub __FILE__
+          runner_with :help, :subcommands do
+            desc 'Ruby utitilies for local projects.'
+            subcommands
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'avm/tools/core_ext'
+
+module Avm
+  module Tools
+    class Runner
+      class AppSrc
+        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?
+
+            ' [' + {
+              'CLASS' => sub.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/app_src/test.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'avm/tools/core_ext'
+require 'avm/sources/tests/builder'
+
+module Avm
+  module Tools
+    class Runner
+      class AppSrc
+        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(:instance_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/app_src/update.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'avm/tools/core_ext'
+
+module Avm
+  module Tools
+    class Runner
+      class AppSrc
+        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/app_src/version_bump.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'avm/version_number'
+require 'eac_cli/core_ext'
+
+module Avm
+  module Tools
+    class Runner
+      class AppSrc
+        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).if_respond('version')
+          end
+
+          def target_version_uncached
+            r = current_version
+            %w[new segment major minor patch].each do |option|
+              option_value = parsed[option]
+              next if option_value.blank?
+
+              r = send("target_version_from_#{option}", r, option_value)
+            end
+            r
+          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