avm-tools 0.48.0 → 0.53.0

data/lib/avm/git/subrepo_checks.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'eac_launcher/git/base'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    class SubrepoChecks
+      enable_console_speaker
+      enable_simple_cache
+      attr_accessor :check_remote, :fix_parent
+      common_constructor :repository
+
+      def add_all_subrepos
+        add_subrepos(
+          *repository.command('subrepo', '-q', 'status').execute!.split("\n").map(&:strip)
+          .select(&:present?)
+        )
+      end
+
+      def add_subrepos(*subpath_list)
+        subpath_list.each do |subpath|
+          subpaths.add(subpath)
+        end
+        reset_cache
+        self
+      end
+
+      def check_options
+        { fix_parent: fix_parent, check_remote: check_remote }
+      end
+
+      def show_result
+        checks.each(&:show_result)
+        infov 'Result', result.label
+      end
+
+      private
+
+      def checks_uncached
+        subpaths.map do |subpath|
+          ::Avm::Git::SubrepoCheck.new(repository.subrepo(subpath), check_options)
+        end
+      end
+
+      def result_uncached
+        error_count = checks.count { |check| check.result.error? }
+        ::Avm::Result.success_or_error(
+          error_count.zero?,
+          "#{error_count} of #{checks.count} subrepos failed"
+        )
+      end
+
+      def subpaths
+        @subpaths ||= ::Set.new
+      end
+    end
+  end
+end

data/lib/avm/instances/configuration/_rubocop.rb

@@ -12,7 +12,7 @@ module Avm
 
       def rubocop_gemfile
         gemfile_path = read_entry(RUBOCOP_GEMFILE_KEY)
-        return nil unless gemfile_path.present?
+        return nil if gemfile_path.blank?
 
         gemfile_path = gemfile_path.to_pathname.expand_path(storage_path.parent)
         return gemfile_path if gemfile_path.file?

data/lib/avm/instances/configuration/_tests.rb

@@ -1,13 +1,27 @@
 # frozen_string_literal: true
 
+require 'eac_ruby_gems_utils/gem'
+
 module Avm
   module Instances
     class Configuration < ::EacRubyUtils::Configs
+      BUNDLE_TEST_COMMAND_KEY = 'test.bundle_command'
       TEST_COMMAND_KEY = 'test.command'
 
+      def any_test_command
+        bundle_test_command || test_command
+      end
+
       def test_command
         read_command(TEST_COMMAND_KEY)
       end
+
+      def bundle_test_command
+        read_entry(BUNDLE_TEST_COMMAND_KEY).if_present do |v|
+          args = v.is_a?(::Enumerable) ? v.map(&:to_s) : ::Shellwords.split(v)
+          ::EacRubyGemsUtils::Gem.new(::File.dirname(storage_path)).bundle(*args).chdir_root
+        end
+      end
     end
   end
 end

data/lib/avm/rails/runners/runner.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/console/docopt_runner'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Rails
+    module Runners
+      class Runner < ::EacRubyUtils::Console::DocoptRunner
+        enable_console_speaker
+        enable_simple_cache
+
+        DOC = <<~DOC
+          Runs a Ruby code with "rails runner".
+
+          Usage:
+            __PROGRAM__ [options] <code>
+            __PROGRAM__ --version
+            __PROGRAM__ -h | --help
+
+          Options:
+            -h --help         Show this screen.
+            -e --environment  Specifies the environment for the runner to
+                              operate (test/development/production). Default: "development".
+        DOC
+
+        def run
+          infov 'Runner arguments', runner_args
+          infov 'Environment', context(:instance).host_env
+          runner_command.system!
+        end
+
+        def runner_command_uncached
+          context(:instance).bundle(*bundle_args)
+        end
+
+        def bundle_args
+          %w[exec rails runner] + runner_args
+        end
+
+        def runner_args
+          options.fetch('--environment').if_present([]) { |v| ['--environment', v] } +
+            [options.fetch('<code>')]
+        end
+      end
+    end
+  end
+end

data/lib/avm/result.rb

@@ -2,12 +2,13 @@
 
 require 'colorized_string'
 require 'eac_ruby_utils/listable'
+require 'eac_ruby_utils/core_ext'
 
 module Avm
   class Result < ::SimpleDelegator
     include ::EacRubyUtils::Listable
 
-    lists.add_string :type, :success, :error, :neutral
+    lists.add_string :type, :success, :error, :neutral, :pending, :outdated
 
     lists.type.values.each do |type| # rubocop:disable Style/HashEachMethods
       class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
@@ -20,10 +21,19 @@ module Avm
     TYPE_SUCCESS_COLOR = 'green'
     TYPE_ERROR_COLOR = 'red'
     TYPE_NEUTRAL_COLOR = 'light_black'
+    TYPE_PENDING_COLOR = 'yellow'
+    TYPE_OUTDATED_COLOR = 'blue'
 
     class << self
-      def success_or_error(value, success)
-        new(value, success ? ::Avm::Result::TYPE_SUCCESS : ::Avm::Result::TYPE_ERROR)
+      # Return Avm::Result.success(success_value) if +success+ is truthy.
+      # Return Avm::Result.error(error_value || success_value) if +success+ is falsely.
+      # @return [Avm::Result]
+      def success_or_error(success, success_value, error_value = nil)
+        if success
+          self.success(success_value)
+        else
+          error(error_value.presence || success_value)
+        end
       end
     end
 

data/lib/avm/ruby/gems.rb

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

data/lib/avm/ruby/gems/generator.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'avm/patches/object/template'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Ruby
+    module Gems
+      class Generator
+        IDENT = '  '
+        JOBS = %w[root_directory gemspec root_lib version_lib static gemfile_lock rspec].freeze
+        TEMPLATE_VARIABLES = %w[lib_path name root_module].freeze
+
+        enable_console_speaker
+        enable_simple_cache
+        common_constructor :root_directory, :options, default: [{}] do
+          self.root_directory = root_directory.to_pathname
+          run
+        end
+
+        def eac_ruby_gem_support_version
+          dependency_version('eac_ruby_gem_support')
+        end
+
+        def eac_ruby_utils_version
+          dependency_version('eac_ruby_utils')
+        end
+
+        def name
+          root_directory.basename.to_s
+        end
+
+        def lib_path
+          name.split('-').join('/')
+        end
+
+        def root_module
+          lib_path.camelize
+        end
+
+        def root_module_close
+          root_module_components.count.times.map do |index|
+            (IDENT * index) + 'end'
+          end.reverse.join("\n")
+        end
+
+        def root_module_inner_identation
+          IDENT * root_module_components.count
+        end
+
+        def root_module_open
+          root_module_components.each_with_index.map do |component, index|
+            (IDENT * index) + 'module ' + component
+          end.join("\n")
+        end
+
+        def root_module_components
+          root_module.split('::')
+        end
+
+        protected
+
+        def apply_to_root_directory(template, subpath)
+          if template.is_a?(::EacRubyUtils::Templates::Directory)
+            template.children.each do |child|
+              apply_to_root_directory(child, subpath.join(child.basename))
+            end
+          elsif template.is_a?(::EacRubyUtils::Templates::File)
+            template.apply_to_file(template_variables, root_directory.join(subpath))
+          else
+            raise "Unknown template object: #{template}"
+          end
+        end
+
+        def dependency_version(gem_name)
+          VersionBuilder.new(gem_name, options).to_s
+        end
+
+        def generate_gemspec
+          template_apply('gemspec', "#{name}.gemspec")
+        end
+
+        def generate_gemfile_lock
+          self_gem.bundle('install').chdir_root.execute!
+        end
+
+        def generate_root_directory
+          root_directory.mkpath
+        end
+
+        def generate_root_lib
+          template_apply('root_lib', "lib/#{lib_path}.rb")
+        end
+
+        def generate_rspec
+          self_gem.bundle('exec', 'rspec').chdir_root.execute!
+        end
+
+        def generate_static
+          template.child('static').apply(self, root_directory)
+        end
+
+        def generate_version_lib
+          template_apply('version', "lib/#{lib_path}/version.rb")
+        end
+
+        def run
+          infov 'Root directory', root_directory
+          infov 'Gem name', name
+          JOBS.each do |job|
+            infom "Generating #{job.humanize}..."
+            send("generate_#{job}")
+          end
+        end
+
+        def self_gem_uncached
+          ::EacRubyGemsUtils::Gem.new(root_directory)
+        end
+
+        def template_apply(from, to)
+          target = root_directory.join(to)
+          target.dirname.mkpath
+          template.child("#{from}.template").apply_to_file(self, target.to_path)
+        end
+
+        class VersionBuilder
+          enable_simple_cache
+          common_constructor :gem_name, :options
+
+          def to_s
+            r = "'~> #{two_segments}'"
+            r += ", '>= #{three_segments}'" if segments.count >= 3 && segments[2].positive?
+            r
+          end
+
+          # @return [Gem::Version]
+          def version
+            (options_version || default_version)
+          end
+
+          def two_segments
+            segments.first(2).join('.')
+          end
+
+          def three_segments
+            segments.first(3).join('.')
+          end
+
+          private
+
+          def segments_uncached
+            version.release.to_s.split('.').map(&:to_i)
+          end
+
+          def default_version
+            ::Gem.loaded_specs[gem_name].version
+          end
+
+          def options_version
+            options["#{gem_name}_version".to_sym].if_present do |v|
+              ::Gem::Version.new(v)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/ruby/rubocop/_gemfile.rb

@@ -18,7 +18,7 @@ module Avm
       end
 
       def rubocop_gemfile?
-        return false unless mygem.present?
+        return false if mygem.blank?
 
         mygem.bundle('install').execute!
         mygem.gemfile_lock_gem_version('rubocop').present?

data/lib/avm/stereotypes/eac_webapp_base0/runner/data/dump.rb

@@ -14,7 +14,7 @@ module Avm
             include ::EacRubyUtils::SimpleCache
             include ::EacRubyUtils::Console::Speaker
 
-            DUMP_EXPIRE_TIME = 1.days
+            DUMP_EXPIRE_TIME = 1.day
             DEFAULT_DUMP_PATH_ENTRY_SUFFIX = 'data.default_dump_path'
             NO_DUMP_MESSAGE = 'Dump "%s" already exist and rewrite options was no setted nor ' \
               'dump was expired.'

data/lib/avm/tools/runner/eac_rails_base0/runner.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'avm/rails/runners/runner'
+
+module Avm
+  module Tools
+    class Runner < ::EacRubyUtils::Console::DocoptRunner
+      class EacRailsBase0 < ::EacRubyUtils::Console::DocoptRunner
+        class Runner < ::Avm::Rails::Runners::Runner
+        end
+      end
+    end
+  end
+end

data/lib/avm/tools/runner/eac_redmine_base0/runner.rb

@@ -1,41 +1,12 @@
 # frozen_string_literal: true
 
-require 'eac_ruby_utils/console/docopt_runner'
-require 'eac_cli/default_runner'
+require 'avm/rails/runners/runner'
 
 module Avm
   module Tools
     class Runner < ::EacRubyUtils::Console::DocoptRunner
       class EacRedmineBase0 < ::EacRubyUtils::Console::DocoptRunner
-        class Runner < ::EacRubyUtils::Console::DocoptRunner
-          include ::EacCli::DefaultRunner
-
-          runner_definition do
-            desc 'Runs a Ruby code with "rails runner".'
-            arg_opt '-e', '--environment', 'Specifies the environment for the runner to operate' \
-              " under (test/development/production).\n" \
-              'Default: development'
-            pos_arg 'code'
-          end
-
-          def run
-            infov 'Runner arguments', runner_args
-            infov 'Environment', context(:instance).host_env
-            runner_command.system!
-          end
-
-          def runner_command_uncached
-            context(:instance).bundle(*bundle_args)
-          end
-
-          def bundle_args
-            %w[exec rails runner] + runner_args
-          end
-
-          def runner_args
-            options.fetch('--environment').if_present([]) { |v| ['--environment', v] } +
-              [options.fetch('<code>')]
-          end
+        class Runner < ::Avm::Rails::Runners::Runner
         end
       end
     end

data/lib/avm/tools/runner/git/auto_commit.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'avm/git/auto_commit_path'
+require 'eac_cli/default_runner'
+
+module Avm
+  module Tools
+    class Runner < ::EacRubyUtils::Console::DocoptRunner
+      class Git < ::EacRubyUtils::Console::DocoptRunner
+        class AutoCommit < ::EacRubyUtils::Console::DocoptRunner
+          include ::EacCli::DefaultRunner
+
+          runner_definition do
+            desc 'Commit with message based in content commited.'
+            bool_opt '-d', '--dirty', 'Select dirty files.'
+            pos_arg 'paths', repeat: true, optional: true
+          end
+
+          def run
+            clear_stage
+            banner
+            run_paths
+          end
+
+          private
+
+          def banner
+            infov 'Paths', paths.count
+          end
+
+          def clear_stage
+            infom 'Clearing stage...'
+            context(:git).system!('reset', 'HEAD')
+          end
+
+          def dirty_paths
+            return [] unless options.fetch('--dirty')
+
+            context(:git).dirty_files.map { |d| context(:git).root_path.join / d.path }
+          end
+
+          def paths_uncached
+            (options.fetch('<paths>')
+              .map { |p| p.to_pathname.expand_path } + dirty_paths)
+              .reject(&:directory?)
+              .sort.uniq.map { |path| ::Avm::Git::AutoCommitPath.new(context(:git), path) }
+          end
+
+          def run_paths
+            paths.each(&:run)
+          end
+        end
+      end
+    end
+  end
+end