eac_tools 0.122.0 → 0.123.1

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/runners/bundler/gemfile_local.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      module Runners
+        class Bundler
+          class GemfileLocal
+            runner_with :help do
+              bool_opt '-w', '--write', 'Write the Gemfile.local file.'
+            end
+            delegate :siblings, to: :builder
+
+            def run
+              start_banner
+              builder.run_bundle
+              siblings_banner
+              write_gemfile_local
+            end
+
+            private
+
+            def start_banner
+              runner_context.call(:source_banner)
+              infov 'Parent', the_source.parent
+            end
+
+            def siblings_banner
+              infov 'Siblings', siblings.count
+              siblings.each do |sibling|
+                infov '  * ', sibling.relative_path
+              end
+            end
+
+            def write_gemfile_local
+              return unless parsed.write?
+
+              infom "Writing #{builder.target_path}..."
+              builder.write_target_file
+            end
+
+            def the_source
+              runner_context.call(:source)
+            end
+
+            # @return [Avm::EacRubyBase1::Sources::GemfileLocal]
+            def builder_uncached
+              ::Avm::EacRubyBase1::Sources::GemfileLocal.new(the_source)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/runners/bundler/gemfile_lock/git.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      module Runners
+        class Bundler
+          class GemfileLock
+            module Git
+              private
+
+              def git_continue
+                infom "Adding \"#{gemfile_lock}\"..."
+                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 = 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_repo
+                instance.scm.git_repo
+              end
+
+              def git_reset_checkout
+                git_reset_gemfile_lock
+                git_checkout_gemfile_lock
+              end
+
+              def git_checkout_gemfile_lock
+                infom 'Checkouting...'
+                git_repo.command('checkout', '--', gemfile_lock).system!
+              end
+
+              def git_reset_gemfile_lock
+                infom 'Reseting...'
+                git_repo.command('reset', gemfile_lock).system! if
+                ::File.exist?(gemfile_lock)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/runners/bundler/gemfile_lock.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      module Runners
+        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
+              ::FileUtils.rm_f(gemfile_lock)
+            end
+
+            def rebasing?
+              git_repo.root_path.join('.git', 'rebase-merge').exist?
+            end
+
+            def bundle_install
+              infom '"bundle install"...'
+              bundle_run('install')
+            end
+
+            def bundle_update
+              infom '"bundle update"...'
+              bundle_run('update')
+            end
+
+            # @return [Pathname]
+            def gemfile_lock
+              source.gemfile_lock_path
+            end
+
+            def bundle_run(*)
+              instance.bundle(*).system!
+            end
+
+            def conflict?
+              rebase_conflict? || cherry_conflict?
+            end
+
+            def rebase_conflict?
+              git_repo.root_path.join('.git', 'REBASE_HEAD').exist?
+            end
+
+            def cherry_conflict?
+              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(:subject)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/runners/bundler/incompatible.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      module Runners
+        class Bundler
+          class Incompatible
+            runner_with :help do
+              desc 'Identify incompatible gems in a "Gemfile.lock" file.'
+              bool_opt '-l', '--last', 'Process the last \"bundle update\" result.'
+            end
+
+            def run
+              infov 'Cache path', fs_cache.content_path
+              infov 'Cached?', fs_cache.stored?
+              parser.gems_in_conflict.each do |gem_in_conflict|
+                print_gem_in_conflict(gem_in_conflict)
+              end
+            end
+
+            private
+
+            def bundle_update
+              infom 'Running "bundle update"...'
+              runner_context.call(:subject).bundle('update').execute[:stdout]
+            end
+
+            def content_path
+              fs_cache.write(bundle_update) unless fs_cache.stored? && parsed.last?
+              fs_cache.content_path
+            end
+
+            def fs_object_id
+              runner_context.call(:subject).path.to_s.variableize
+            end
+
+            def gem_title(gem_in_conflict)
+              gem_in_conflict.gem_name
+            end
+
+            def parser_uncached
+              ::Avm::EacRubyBase1::Bundler::IncompatibleParser.new(content_path)
+            end
+
+            def print_gem_in_conflict(gem_in_conflict)
+              infov 'Gem', gem_title(gem_in_conflict)
+              gem_in_conflict.versions_requirements.each do |requirement|
+                print_requirement(requirement)
+              end
+            end
+
+            def print_requirement(req)
+              infov "  #{requirement_title(req)}", requirement_value(req)
+            end
+
+            def requirement_stack(req)
+              req.stack.map { |d| "#{d.gem_name} (#{d.version})" }.join(' > '.green)
+            end
+
+            def requirement_title(req)
+              req.requirements_source.if_present('*')
+            end
+
+            def requirement_value(req)
+              requirement_stack(req)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/runners/bundler.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      module Runners
+        class Bundler
+          runner_with :help, :subcommands do
+            desc 'Ruby\'s bundler utitilies for local projects.'
+            subcommands
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/tests/base.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      module Tests
+        class Base
+          include ::EacRubyUtils::Listable
+
+          enable_simple_cache
+          lists.add_string :result, :failed, :nonexistent, :successful
+
+          common_constructor :gem
+
+          def elegible?
+            dependency_present? && gem.root.join(test_directory).exist?
+          end
+
+          def dependency_present?
+            gem.gemfile_path.exist? && gem.gemfile_lock_gem_version(dependency_gem).present?
+          end
+
+          def name
+            self.class.name.demodulize.gsub(/Test\z/, '')
+          end
+
+          def to_s
+            "#{gem}[#{name}]"
+          end
+
+          private
+
+          def logs_uncached
+            ::EacFs::Logs.new.add(:stdout).add(:stderr)
+          end
+
+          def result_uncached
+            return RESULT_NONEXISTENT unless elegible?
+
+            exec_run_with_log ? RESULT_SUCCESSFUL : RESULT_FAILED
+          end
+
+          def exec_run
+            gem.bundle('exec', *bundle_exec_args).chdir_root.execute
+          end
+
+          def exec_run_with_log # rubocop:disable Naming/PredicateMethod
+            r = exec_run
+            logs[:stdout].write(r[:stdout])
+            logs[:stderr].write(r[:stderr])
+            r[:exit_code].zero?
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/tests/minitest.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      module Tests
+        class Minitest < ::Avm::EacRubyBase1::Sources::Tests::Base
+          def bundle_exec_args
+            %w[rake test]
+          end
+
+          def dependency_gem
+            'minitest'
+          end
+
+          def elegible?
+            super && gem.rakefile_path.exist?
+          end
+
+          def test_directory
+            'test'
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/tests/multiple/decorated_gem.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      module Tests
+        class Multiple
+          class DecoratedGem < ::SimpleDelegator
+            enable_speaker
+
+            def prepare
+              return unless gemfile_path.exist?
+
+              log('running "bundle install"...')
+              return if bundle('install').execute.fetch(:exit_code).zero?
+
+              unless can_remove_gemfile_lock?
+                raise '"bundle install" failed and the Gemfile.lock is part of gem' \
+                      '(Should be changed by developer)'
+              end
+
+              prepare_with_removable_gemfile_lock
+            end
+
+            def tests
+              [::Avm::EacRubyBase1::Sources::Tests::Minitest.new(__getobj__),
+               ::Avm::EacRubyBase1::Sources::Tests::Rspec.new(__getobj__)]
+            end
+
+            private
+
+            def log(message)
+              infov self, message
+            end
+
+            def prepare_with_removable_gemfile_lock
+              log('"bundle install" failed, removing Gemfile.lock and trying again...')
+              gemfile_lock_path.unlink if gemfile_lock_path.exist?
+              bundle('install').execute!
+            end
+
+            def can_remove_gemfile_lock?
+              files.exclude?(gemfile_lock_path.relative_path_from(root))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/tests/multiple/result.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      module Tests
+        class Multiple
+          class Result
+            common_constructor :result
+
+            COLORS = {
+              ::Avm::EacRubyBase1::Sources::Tests::Base::RESULT_FAILED => :red,
+              ::Avm::EacRubyBase1::Sources::Tests::Base::RESULT_NONEXISTENT => :white,
+              ::Avm::EacRubyBase1::Sources::Tests::Base::RESULT_SUCCESSFUL => :green
+            }.freeze
+
+            def tag
+              result.to_s.send(color)
+            end
+
+            def color
+              COLORS.fetch(result)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/tests/multiple.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      module Tests
+        class Multiple
+          enable_speaker
+          enable_simple_cache
+          common_constructor :gems, :options, default: [{}]
+          set_callback :initialize, :after, :run
+
+          def ok?
+            failed_tests.none?
+          end
+
+          def only
+            options[:only]
+          end
+
+          private
+
+          def all_tests_uncached
+            decorated_gems.flat_map(&:tests)
+          end
+
+          def clear_logs
+            all_tests.each do |test|
+              test.logs.remove_all
+            end
+          end
+
+          def prepare_all_gems
+            infom 'Preparing all gems...'
+            decorated_gems.each(&:prepare)
+          end
+
+          def decorated_gems_uncached
+            r = gems
+            r = r.select { |gem| only.include?(gem.name) } if only.present?
+            r.map { |gem| DecoratedGem.new(gem) }
+          end
+
+          def failed_tests_uncached
+            all_tests.select do |r|
+              r.result == ::Avm::EacRubyBase1::Sources::Tests::Base::RESULT_FAILED
+            end
+          end
+
+          def final_results_banner
+            if failed_tests.any?
+              warn 'Some test did not pass:'
+              failed_tests.each do |test|
+                infov '  * Test', test
+                info test.logs.truncate_all
+              end
+            else
+              success 'All tests passed'
+            end
+          end
+
+          def run
+            start_banner
+            prepare_all_gems
+            test_all_gems
+            final_results_banner
+          ensure
+            clear_logs
+          end
+
+          def start_banner
+            infov 'Gems to test', decorated_gems.count
+          end
+
+          def test_all_gems
+            infom 'Running tests...'
+            all_tests.each do |test|
+              infov test, Result.new(test.result).tag
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/tests/rspec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      module Tests
+        class Rspec < ::Avm::EacRubyBase1::Sources::Tests::Base
+          def bundle_exec_args
+            %w[rspec]
+          end
+
+          def dependency_gem
+            'rspec-core'
+          end
+
+          def test_directory
+            'spec'
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/update/changes/dependencies_requirements.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      module Update
+        module Changes
+          class DependenciesRequirements < ::Avm::Sources::Change
+            enable_memoized
+
+            # @return [void]
+            def perform
+              return if source.gemspec_path.blank?
+
+              source.bundle.system!
+              update_gemspec
+              source.bundle.system!
+            end
+
+            RUBOCOP_OK_CODES = [256].freeze
+
+            protected
+
+            # @param dependency [Avm::EacRubyBase1::Rubygems::Gemspec::Dependency]
+            # @return [Array<String>]
+            def dependency_requirements_list(dependency)
+              ::Avm::EacRubyBase1::PreferredVersionRequirements.new(
+                source.gemfile_lock_gem_version(dependency.gem_name)
+              ).to_requirements_list
+            end
+
+            # @return [String]
+            def format_gemspec
+              source.rubocop_root_command.autocorrect(true)
+                .file(source.gemspec_path)
+                .execute!(exit_outputs: RUBOCOP_OK_CODES.index_with { |_k| nil })
+            end
+
+            # @return [Avm::EacRubyBase1::Rubygems::Gemspec]
+            memoize def gemspec
+              ::Avm::EacRubyBase1::Rubygems::Gemspec.from_file(source.gemspec_path)
+            end
+
+            # @return [String]
+            def update_gemspec
+              gemspec.dependencies.each do |dependency|
+                dependency.version_specs = dependency_requirements_list(dependency)
+              end
+              gemspec.write(source.gemspec_path)
+              format_gemspec
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/update/changes/gemfile_lock.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      module Update
+        module Changes
+          class GemfileLock < ::Avm::Sources::Change
+            # @return [String]
+            def commit_message
+              i18n_translate(
+                __method__,
+                gemfile_lock_path: source.gemfile_lock_path.relative_path_from(source.path)
+              )
+            end
+
+            # @return [void]
+            def perform
+              source.bundle_update.execute!
+            rescue ::EacRubyUtils::Envs::ExecutionError
+              raise ::Avm::Sources::UpdateError
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-eac_ruby_base1/lib/avm/eac_ruby_base1/sources/update/changes/rubocop_format.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Avm
+  module EacRubyBase1
+    module Sources
+      module Update
+        module Changes
+          class RubocopFormat < ::Avm::Sources::Change
+            # @return [void]
+            def perform
+              return if autofix
+
+              disable_offenses
+              autofix
+            end
+
+            # @return [Boolean]
+            def autofix
+              source.rubocop_root_command.autocorrect(true).system
+            end
+
+            # @return [void]
+            def disable_offenses
+              source.rubocop_offenses.disable_all
+            end
+          end
+        end
+      end
+    end
+  end
+end