avm-tools 0.102.2 → 0.105.0

data/lib/avm/docker/registry.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/self/instance'
-require 'eac_docker/registry'
-require 'eac_ruby_utils/core_ext'
-
-module Avm
-  module Docker
-    class Registry < ::EacDocker::Registry
-      class << self
-        def default
-          @default ||= new(::Avm::Self.instance.read_entry(
-                             ::Avm::Self::Instance::EntryKeys::DOCKER_REGISTRY_NAME
-                           ))
-        end
-      end
-    end
-  end
-end

data/lib/avm/docker.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/require_sub'
-
-module Avm
-  module Docker
-    ::EacRubyUtils.require_sub(__FILE__)
-  end
-end

data/lib/avm/eac_redmine_base0/docker_image.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/core_ext'
-require 'avm/instances/docker_image'
-
-module Avm
-  module EacRedmineBase0
-    class DockerImage < ::Avm::Instances::DockerImage
-      enable_simple_cache
-
-      REDMINE_SOURCE_HOST_SUBPATH = 'redmine_source'
-
-      def avm_fs_cache_object_id
-        instance.id
-      end
-
-      def redmine_user
-        'redmine'
-      end
-
-      def redmine_user_home
-        "/home/#{redmine_user}"
-      end
-
-      def redmine_path
-        "#{redmine_user_home}/redmine_app"
-      end
-
-      def start_path
-        '/start.sh'
-      end
-
-      private
-
-      def git_repo_uncached
-        ::EacGit::Local.new(instance.source_instance.fs_path)
-      end
-
-      def redmine_source_git_id
-        git_repo.rev_parse('HEAD')
-      end
-
-      def redmine_source_path_uncached
-        r = provide_dir.join(REDMINE_SOURCE_HOST_SUBPATH)
-        ::FileUtils.rm_rf(r.to_path)
-        r.mkpath
-        git_repo.commit(redmine_source_git_id).archive_to_dir(r).system!
-        REDMINE_SOURCE_HOST_SUBPATH
-      end
-    end
-  end
-end

data/lib/avm/eac_redmine_base0.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/require_sub'
-
-module Avm
-  module EacRedmineBase0
-    ::EacRubyUtils.require_sub(__FILE__)
-  end
-end

data/template/avm/eac_redmine_base0/docker_image/install_settings.sh.template

@@ -1,29 +0,0 @@
-# Database (PostgreSQL)
-export postgresql_database=redmine
-export postgresql_database_test=redmine_test
-export postgresql_user=redmine
-export postgresql_password=redmine
-
-# Git hosting
-export gitolite_user=git
-export gitolite_user_home="/var/lib/$gitolite_user"
-export redmine_git_hosting_ssh_key_name=redmine_git_hosting_id
-export git_repositories_hierarchical_organisation=false
-
-# Address
-export address_https=false
-export address_host="%%web.hostname%%"
-export address_port=
-export address_path=
-
-# Mail
-export smtp_server='mail.trf1.jus.br'
-export smtp_port='25'
-export smtp_domain='trf1.jus.br'
-export smtp_tls='false'
-export smtp_enable_starttls_auto=''
-export smtp_openssl_verify_mode=''
-export smtp_authentication='none'
-export smtp_username=''
-export smtp_password=''
-export mail_from='"redmine-trf1_0" <redmine@trf1.jus.br>'

data/vendor/eac_cli/lib/eac_cli/docopt/doc_builder/alternative.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-require 'eac_cli/docopt_runner'
-
-module EacCli
-  module Docopt
-    class DocBuilder
-      class Alternative
-        common_constructor :alternative
-
-        def to_s
-          (
-            [::EacCli::DocoptRunner::PROGRAM_MACRO] +
-              alternative.options_argument?.if_present([]) { |_v| ['[options]'] } +
-              options +
-              positionals
-          ).join(::EacCli::Docopt::DocBuilder::SEP)
-        end
-
-        def options
-          alternative.options.select(&:show_on_usage?).map do |option|
-            ::EacCli::Docopt::DocBuilder.option_long(option)
-          end
-        end
-
-        def option_argument(option)
-          b = option.long
-          b += '=<value>' if option.argument?
-          b
-        end
-
-        def positionals
-          alternative.positional.map { |p| positional(p) }.reject(&:blank?)
-        end
-
-        def positional(positional)
-          return unless positional.visible?
-
-          if positional.subcommand?
-            ::EacCli::DocoptRunner::SUBCOMMANDS_MACRO
-          else
-            r = "<#{positional.name}>"
-            r += '...' if positional.repeat?
-            r = "[#{r}]" if positional.optional?
-            r
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/docopt/doc_builder.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-require 'eac_cli/docopt_runner'
-
-module EacCli
-  module Docopt
-    class DocBuilder
-      require_sub __FILE__
-      common_constructor :definition
-
-      SEP = ' '
-      IDENT = SEP * 2
-      OPTION_DESC_SEP = IDENT * 2
-
-      class << self
-        def option_long(option)
-          b = option.long
-          b += '=<value>' if option.argument?
-          b
-        end
-
-        def option_short(option)
-          b = option.short
-          b += '=<value>' if option.argument?
-          b
-        end
-
-        def option_usage_full(option)
-          if option.long.present?
-            [option.short, option_long(option)].reject(&:blank?).join(SEP)
-          else
-            option_short(option)
-          end
-        end
-      end
-
-      def option_definition(option)
-        self.class.option_usage_full(option) + option.description.if_present('') do |v|
-          OPTION_DESC_SEP + v
-        end
-      end
-
-      def section(header, include_header = true)
-        b = include_header ? "#{header.humanize}:\n" : ''
-        b += send("self_#{header}") + "\n"
-        definition.alternatives.each do |alternative|
-          b += IDENT + ::EacCli::Docopt::DocBuilder::Alternative.new(alternative).to_s + "\n"
-        end
-        b
-      end
-
-      def options_section
-        "Options:\n" +
-          definition.alternatives.flat_map(&:options)
-                    .map { |option| IDENT + option_definition(option) + "\n" }.join
-      end
-
-      def usage_section
-        "Usage:\n" +
-          definition.alternatives.map do |alternative|
-            IDENT + ::EacCli::Docopt::DocBuilder::Alternative.new(alternative).to_s + "\n"
-          end.join
-      end
-
-      def to_s
-        "#{definition.description}\n\n#{usage_section}\n#{options_section}\n"
-      end
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/docopt/runner_context_replacement.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module EacCli
-  module Docopt
-    class RunnerContextReplacement
-      common_constructor :runner
-
-      def argv
-        runner.settings[:argv] || ARGV
-      end
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/docopt/runner_extension.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/docopt/doc_builder'
-require 'eac_cli/docopt/runner_context_replacement'
-require 'eac_cli/runner'
-require 'eac_cli/docopt_runner'
-
-module EacCli
-  module Docopt
-    module RunnerExtension
-      extend ::ActiveSupport::Concern
-
-      included do
-        prepend InstanceMethods
-      end
-
-      class << self
-        def check(klass)
-          return unless klass < ::EacCli::DocoptRunner
-
-          ::EacCli::Runner.alias_runner_class_methods(klass, '', 'eac_cli')
-          ::EacCli::Runner.alias_runner_class_methods(klass, 'original', '')
-
-          klass.include(self)
-        end
-      end
-
-      module InstanceMethods
-        def doc
-          ::EacCli::Docopt::DocBuilder.new(self.class.runner_definition).to_s
-        end
-
-        def docopt_options
-          super.merge(options_first: self.class.runner_definition.options_first?)
-        end
-
-        def runner_context
-          @runner_context ||= ::EacCli::Docopt::RunnerContextReplacement.new(self)
-        end
-      end
-
-      def extra_available_subcommands
-        self.class.constants
-            .map { |name| self.class.const_get(name) }
-            .select { |c| c.instance_of? Class }
-            .select { |c| c.included_modules.include?(::EacCli::Runner) }
-            .map { |c| c.name.demodulize.underscore.dasherize }
-      end
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/docopt_runner/_doc.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class DocoptRunner
-    PROGRAM_MACRO = '__PROGRAM__'
-
-    def source_doc
-      setting_value(:doc)
-    end
-
-    def target_doc
-      source_doc.gsub(PROGRAM_MACRO, target_program_name).strip + "\n"
-    end
-
-    def source_program_name
-      setting_value(:program_name, false)
-    end
-
-    def target_program_name
-      [source_program_name, ENV['PROGRAM_NAME'], $PROGRAM_NAME].find(&:present?)
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/docopt_runner/_settings.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/settings_provider'
-
-module EacCli
-  class DocoptRunner
-    include ::EacRubyUtils::SettingsProvider
-
-    attr_reader :settings
-
-    private
-
-    def setting_value(key, required = true)
-      super(key, required: required, order: %w[method settings_object constant])
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/docopt_runner/_subcommands.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string/inflections'
-require 'shellwords'
-
-module EacCli
-  class DocoptRunner
-    SUBCOMMAND_ARG = '<subcommand>'
-    SUBCOMMAND_ARGS_ARG = '<subcommand-args>'
-    SUBCOMMANDS_MACRO = '__SUBCOMMANDS__'
-
-    def subcommands?
-      source_doc.include?(SUBCOMMANDS_MACRO)
-    end
-
-    def check_subcommands
-      return unless subcommands?
-
-      singleton_class.include(SubcommandsSupport)
-      check_subcommands_arg
-      return if singleton_class.method_defined?(:run)
-
-      singleton_class.send(:alias_method, :run, :run_with_subcommand)
-    end
-
-    module SubcommandsSupport
-      EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME = :extra_available_subcommands
-
-      def check_subcommands_arg
-        if subcommand_arg_as_list?
-          singleton_class.include(SubcommandsSupport::SubcommandArgAsList)
-        else
-          singleton_class.include(SubcommandsSupport::SubcommandArgAsArg)
-        end
-      end
-
-      def run_with_subcommand
-        if subcommand_name
-          check_valid_subcommand
-          subcommand_run
-        else
-          run_without_subcommand
-        end
-      end
-
-      def subcommand
-        @subcommand ||= subcommand_class_name(subcommand_name).constantize.create(
-          argv: subcommand_args,
-          program_name: subcommand_program,
-          parent: self
-        )
-      end
-
-      def subcommand_run
-        if !subcommand.is_a?(::EacCli::DocoptRunner) &&
-           subcommand.respond_to?(:run_run)
-          subcommand.run_run
-        else
-          subcommand.run
-        end
-      end
-
-      def target_doc
-        super.gsub(SUBCOMMANDS_MACRO,
-                   "#{target_doc_subcommand_arg} [#{SUBCOMMAND_ARGS_ARG}...]") +
-          "\n" + subcommands_target_doc
-      end
-
-      def docopt_options
-        super.merge(options_first: true)
-      end
-
-      def subcommand_class_name(subcommand)
-        "#{self.class.name}::#{subcommand.underscore.camelize}"
-      end
-
-      def subcommand_arg_as_list?
-        setting_value(:subcommand_arg_as_list, false) || false
-      end
-
-      def subcommand_args
-        options.fetch(SUBCOMMAND_ARGS_ARG)
-      end
-
-      def subcommand_program
-        subcommand_name
-      end
-
-      def available_subcommands
-        r = ::Set.new(setting_value(:subcommands, false) || auto_available_subcommands)
-        if respond_to?(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME, true)
-          r += send(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME)
-        end
-        r.sort
-      end
-
-      def auto_available_subcommands
-        self.class.constants
-            .map { |name| self.class.const_get(name) }
-            .select { |c| c.instance_of? Class }
-            .select { |c| c < ::EacCli::DocoptRunner }
-            .map { |c| c.name.demodulize.underscore.dasherize }
-      end
-
-      def run_without_subcommand
-        "Method #{__method__} should be overrided in #{self.class.name}"
-      end
-
-      protected
-
-      def check_valid_subcommand
-        return if available_subcommands.include?(subcommand_name)
-
-        raise ::Docopt::Exit, "\"#{subcommand_name}\" is not a valid subcommand" \
-          " (Valid: #{available_subcommands.join(', ')})"
-      end
-
-      module SubcommandArgAsArg
-        def target_doc_subcommand_arg
-          SUBCOMMAND_ARG
-        end
-
-        def subcommand_name
-          options.fetch(SUBCOMMAND_ARG)
-        end
-
-        def subcommands_target_doc
-          available_subcommands.inject("Subcommands:\n") do |a, e|
-            a + "  #{e}\n"
-          end
-        end
-      end
-
-      module SubcommandArgAsList
-        def target_doc_subcommand_arg
-          '(' + available_subcommands.join('|') + ')'
-        end
-
-        def subcommand_name
-          available_subcommands.each do |subcommand|
-            return subcommand if options.fetch(subcommand)
-          end
-          nil
-        end
-
-        def subcommands_target_doc
-          "\n"
-        end
-      end
-    end
-  end
-end