avm-tools 0.110.0 → 0.113.1

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/executable.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/simple_cache'
-
-module EacRubyUtils
-  module Envs
-    class Executable
-      include ::EacRubyUtils::SimpleCache
-
-      attr_reader :env, :name, :check_args
-
-      def initialize(env, name, *check_args)
-        @env = env
-        @name = name
-        @check_args = check_args
-      end
-
-      def exist?
-        exist
-      end
-
-      def validate
-        return nil if exist?
-
-        "Program \"#{::Shellwords.join(executable_args)}\" not found in environment #{env}"
-      end
-
-      def validate!
-        message = validate
-
-        raise ProgramNotFoundError, message if message
-      end
-
-      def command(*command_args)
-        validate!
-        env.command(*executable_args, *command_args)
-      end
-
-      def executable_args
-        executable_args_from_envvar || [name]
-      end
-
-      def executable_args_envvar
-        "#{name}_command".variableize.upcase
-      end
-
-      def executable_args_from_envvar
-        ENV[executable_args_envvar].if_present { |v| ::Shellwords.split(v) }
-      end
-
-      private
-
-      def exist_uncached
-        env.command(*executable_args, *check_args).execute!
-        true
-      rescue Errno::ENOENT
-        false
-      end
-
-      class ProgramNotFoundError < ::StandardError; end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/file.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  module Envs
-    class File
-      attr_reader :env, :path
-
-      def initialize(env, path)
-        @env = env
-        @path = path
-      end
-
-      def exist?
-        env.command('stat', path).execute[:exit_code].zero?
-      end
-
-      def read
-        env.command('cat', path).execute!
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/local_env.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/envs/base_env'
-
-module EacRubyUtils
-  module Envs
-    class LocalEnv < ::EacRubyUtils::Envs::BaseEnv
-      def to_s
-        'LOCAL'
-      end
-
-      def command_line(line)
-        line
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/process.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'open3'
-
-module EacRubyUtils
-  module Envs
-    class Process
-      def initialize(command)
-        @data = { command: command }
-        @data[:stdout], @data[:stderr], @data[:exit_code] = Open3.capture3(command)
-        @data[:exit_code] = @data[:exit_code].to_i
-      end
-
-      def to_h
-        @data.dup
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/spawn.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  module Envs
-    class Spawn
-      attr_reader :command, :pid
-
-      def initialize(command)
-        @command = command
-        @pid = ::Process.spawn(command)
-      end
-
-      def kill(signal)
-        ::Process.kill(signal, pid)
-      end
-
-      def kill_at_end(&block)
-        block.call(self)
-      ensure
-        kill('KILL')
-      end
-
-      def to_h
-        { command: command, pid: pid }
-      end
-
-      def wait
-        ::Process.wait pid
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/ssh_env/dasho_options.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/module/common_concern'
-require 'eac_ruby_utils/patches/module/simple_cache'
-
-module EacRubyUtils
-  module Envs
-    class SshEnv < ::EacRubyUtils::Envs::BaseEnv
-      module DashoOptions
-        common_concern
-
-        module ClassMethods
-          def add_nodasho_option(name)
-            return if nodasho_options.include?(name)
-
-            nodasho_options << name
-            const_set("#{name.underscore}_option".upcase, name)
-          end
-
-          def nodasho_options
-            @nodasho_options ||= []
-          end
-        end
-
-        module InstanceMethods
-          def ssh_command_line_dasho_args
-            r = []
-            uri.query_values&.each do |k, v|
-              r += ['-o', "#{k}=#{v}"] unless nodasho_options.include?(k)
-            end
-            r
-          end
-
-          def ssh_command_line_nodasho_args
-            nodasho_options.flat_map do |option_name|
-              uri_query_value(option_name).if_present([]) do |option_value|
-                send("ssh_command_line_#{option_name.underscore}_args", option_value)
-              end
-            end
-          end
-
-          def nodasho_options
-            self.class.nodasho_options
-          end
-
-          def uri_query_value(name)
-            uri.query_values.if_present { |v| v[name] }
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/ssh_env/identity_file.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require 'eac_ruby_utils/envs/ssh_env/dasho_options'
-require 'eac_ruby_utils/listable'
-require 'eac_ruby_utils/patches/object/if_present'
-
-module EacRubyUtils
-  module Envs
-    class SshEnv < ::EacRubyUtils::Envs::BaseEnv
-      module IdentityFile
-        extend ::ActiveSupport::Concern
-
-        included do
-          include ::EacRubyUtils::Envs::SshEnv::DashoOptions
-          add_nodasho_option('IdentityFile')
-        end
-
-        def ssh_command_line_identity_file_args(value)
-          ['-i', value]
-        end
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/ssh_env/quiet.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require 'eac_ruby_utils/boolean'
-require 'eac_ruby_utils/envs/ssh_env/dasho_options'
-
-module EacRubyUtils
-  module Envs
-    class SshEnv < ::EacRubyUtils::Envs::BaseEnv
-      module Quiet
-        extend ::ActiveSupport::Concern
-
-        included do
-          include ::EacRubyUtils::Envs::SshEnv::DashoOptions
-          add_nodasho_option('Quiet')
-        end
-
-        def ssh_command_line_quiet_args(value)
-          ::EacRubyUtils::Boolean.parse(value) ? ['-q'] : []
-        end
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/ssh_env/terminal.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require 'eac_ruby_utils/envs/ssh_env/dasho_options'
-require 'eac_ruby_utils/listable'
-require 'eac_ruby_utils/patches/object/if_present'
-
-module EacRubyUtils
-  module Envs
-    class SshEnv < ::EacRubyUtils::Envs::BaseEnv
-      module Terminal
-        extend ::ActiveSupport::Concern
-
-        included do
-          include ::EacRubyUtils::Envs::SshEnv::DashoOptions
-          add_nodasho_option('Terminal')
-          include ::EacRubyUtils::Listable
-          lists.add_string :terminal_option, :auto, :disable, :enable, :force
-        end
-
-        def ssh_command_line_terminal_args(value)
-          self.class.lists.terminal_option.value_validate!(value)
-          case value
-          when TERMINAL_OPTION_AUTO then ENV['TERM'].present? ? %w[-t] : []
-          when TERMINAL_OPTION_DISABLE then ['-T']
-          when TERMINAL_OPTION_ENABLE then ['-t']
-          when TERMINAL_OPTION_FORCE then ['-tt']
-          else raise "Invalid conditional branch: #{value}"
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/ssh_env.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require 'addressable'
-require 'eac_ruby_utils/envs/base_env'
-require 'eac_ruby_utils/patches/object/if_present'
-require 'eac_ruby_utils/patches/module/require_sub'
-require 'net/ssh'
-require 'shellwords'
-
-module EacRubyUtils
-  module Envs
-    class SshEnv < ::EacRubyUtils::Envs::BaseEnv
-      require_sub __FILE__, include_modules: true
-
-      USER_PATTERN = /[a-z_][a-z0-9_-]*/.freeze
-      HOSTNAME_PATTERN = /[^@]+/.freeze
-      USER_HOSTNAME_PATTERN = /\A(?:(#{USER_PATTERN})@)?(#{HOSTNAME_PATTERN})\z/.freeze
-
-      class << self
-        def parse_uri(uri)
-          uri_by_url(uri) || uri_by_user_hostname(uri) || raise("URI has no SSH scheme: #{uri}")
-        end
-
-        private
-
-        def uri_by_url(url)
-          r = ::Addressable::URI.parse(url)
-          r.scheme == 'ssh' && r.host.present? ? r : nil
-        end
-
-        def uri_by_user_hostname(user_hostname)
-          m = USER_HOSTNAME_PATTERN.match(user_hostname)
-          m ? ::Addressable::URI.new(scheme: 'ssh', host: m[2], user: m[1]) : nil
-        rescue Addressable::URI::InvalidURIError
-          nil
-        end
-      end
-
-      attr_reader :uri
-
-      def initialize(uri)
-        @uri = self.class.parse_uri(uri).freeze
-      end
-
-      def to_s
-        uri.to_s
-      end
-
-      def command_line(line)
-        "#{ssh_command_line} #{Shellwords.escape(line)}"
-      end
-
-      private
-
-      def ssh_command_line
-        (%w[ssh] +
-          %w[nodasho dasho port].flat_map { |m| send("ssh_command_line_#{m}_args") } +
-          [user_hostname_uri])
-          .map { |a| Shellwords.escape(a) }.join(' ')
-      end
-
-      def ssh_command_line_port_args
-        uri.port.if_present([]) do |v|
-          ['-p', v]
-        end
-      end
-
-      def user_hostname_uri
-        r = uri.host
-        r = "#{uri.user}@#{r}" if uri.user.present?
-        r
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/envs/base_env'
-require 'eac_ruby_utils/envs/command'
-require 'eac_ruby_utils/envs/file'
-require 'eac_ruby_utils/envs/local_env'
-require 'eac_ruby_utils/envs/process'
-require 'eac_ruby_utils/envs/ssh_env'
-require 'eac_ruby_utils/envs/executable'
-
-module EacRubyUtils
-  module Envs
-    class << self
-      def local
-        @local ||= ::EacRubyUtils::Envs::LocalEnv.new
-      end
-
-      def ssh(user_hostname)
-        ::EacRubyUtils::Envs::SshEnv.new(user_hostname)
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/fs/clearable_directory.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-require 'pathname'
-
-module EacRubyUtils
-  module Fs
-    class ClearableDirectory < ::Pathname
-      CLEARABLE_BASENAME = '.clearable_directory'
-
-      def clear
-        validate_clearable
-        directory? ? clear_directory : clear_no_directory
-        mkpath
-        ::FileUtils.touch(clearable_note_file.to_path)
-        self
-      end
-
-      def clearable?
-        clearable_negate_message ? true : false
-      end
-
-      def clearable_negate_message
-        return if !exist? || empty?
-        return "Path \"#{self}\" exists, is not empty and is not a directory" unless directory?
-        return if clearable_note_file.exist?
-
-        "Directory \"#{self}\" is not empty and does not have a #{CLEARABLE_BASENAME} file"
-      end
-
-      def clearable_note_file
-        join(CLEARABLE_BASENAME)
-      end
-
-      def validate_clearable
-        message = clearable_negate_message
-        raise message if message
-      end
-
-      private
-
-      def clear_directory
-        children.each do |child|
-          if child.directory?
-            child.rmtree
-          elsif child.file?
-            child.unlink
-          end
-        end
-      end
-
-      def clear_no_directory
-        ::FileUtils.rm_rf(to_path)
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/fs/extname.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  module Fs
-    class << self
-      # A [File.extname] which find multiple extensions (Ex.: .tar.gz).
-      def extname(path, limit = -1)
-        recursive_extension(::File.basename(path), limit)
-      end
-
-      # Shortcut to +extname(2)+.
-      def extname2(path)
-        extname(path, 2)
-      end
-
-      private
-
-      def recursive_extension(basename, limit)
-        return '' if limit.zero?
-
-        m = /\A(.+)(\.[a-z][a-z0-9]*)\z/i.match(basename)
-        if m
-          "#{recursive_extension(m[1], limit - 1)}#{m[2]}"
-        else
-          ''
-        end
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/fs/logs.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string/filters'
-require 'eac_ruby_utils/fs/temp'
-require 'filesize'
-
-module EacRubyUtils
-  module Fs
-    class Logs
-      TRUNCATE_DEFAULT_LENGTH = 1000
-      TRUNCATE_APPEND_TEXT = '(...) '
-
-      def [](label)
-        log_set.fetch(sanitize_label(label))
-      end
-
-      def add(label)
-        log_set[sanitize_label(label)] = ::EacRubyUtils::Fs::Temp.file
-
-        self
-      end
-
-      def remove_all
-        log_set.each_key { |label| remove(label) }
-
-        self
-      end
-
-      def remove(label)
-        log_set.fetch(sanitize_label(label)).remove
-        log_set.delete(sanitize_label(label))
-      end
-
-      def truncate(label, length = TRUNCATE_DEFAULT_LENGTH)
-        content = self[label].read.strip
-        return content if content.length <= TRUNCATE_DEFAULT_LENGTH
-
-        TRUNCATE_APPEND_TEXT + content[content.length - length + TRUNCATE_APPEND_TEXT.length,
-                                       length - TRUNCATE_APPEND_TEXT.length]
-      end
-
-      def truncate_all(length = TRUNCATE_DEFAULT_LENGTH)
-        s = "Files: #{log_set.length}\n"
-        log_set.each do |label, path|
-          x = truncate(label, length)
-          y = [label, path, ::Filesize.from("#{path.size} B").pretty].join(' / ')
-          s += x.blank? ? ">>> #{y} (Blank) <<<" : ">>> #{y}\n#{x}\n<<< #{y}\n"
-        end
-        s
-      end
-
-      private
-
-      def sanitize_label(label)
-        label.to_sym
-      end
-
-      def log_set
-        @log_set ||= {}
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/fs/temp/directory.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/fs/temp/file'
-
-module EacRubyUtils
-  module Fs
-    module Temp
-      class Directory < ::EacRubyUtils::Fs::Temp::File
-        def initialize(*tempfile_args)
-          super(*tempfile_args)
-          mkpath
-        end
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/fs/temp/file.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'pathname'
-require 'tempfile'
-
-module EacRubyUtils
-  module Fs
-    module Temp
-      class File < Pathname
-        # Temporary file
-        def initialize(*tempfile_args)
-          file = Tempfile.new(*tempfile_args)
-          path = file.path
-          file.close
-          file.unlink
-          super(path)
-        end
-
-        def remove
-          if directory?
-            rmtree
-          elsif file?
-            unlink
-          end
-        end
-
-        def remove!
-          remove
-          raise "Tried to remove \"#{self}\", but it yet exists" if exist?
-        end
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/fs/temp.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/require_sub'
-require 'pathname'
-require 'tempfile'
-
-module EacRubyUtils
-  module Fs
-    # Utilities for temporary files.
-    module Temp
-      class << self
-        ::EacRubyUtils.require_sub __FILE__
-
-        # Shortcut to +EacRubyUtils::Fs::Temp::Directory.new(*tempfile_args)+.
-        #
-        # @return [Pathname]
-        def directory(*tempfile_args)
-          ::EacRubyUtils::Fs::Temp::Directory.new(*tempfile_args)
-        end
-
-        # Shortcut to +EacRubyUtils::Fs::Temp::File.new(*tempfile_args)+.
-        #
-        # @return [Pathname]
-        def file(*tempfile_args)
-          ::EacRubyUtils::Fs::Temp::File.new(*tempfile_args)
-        end
-
-        # Run a block while a temporary directory pathname is provided. The directory is deleted
-        # when the block is finished.
-        def on_directory(*tempfile_args)
-          temp_dir = directory(*tempfile_args)
-          begin
-            yield(temp_dir)
-          ensure
-            temp_dir.remove
-          end
-        end
-
-        # Run a block while a temporary file pathname is providade. The file is deleted when block
-        # is finished.
-        def on_file(*tempfile_args)
-          temp_file = file(*tempfile_args)
-          begin
-            yield(temp_file)
-          ensure
-            temp_file.remove
-          end
-        end
-      end
-    end
-  end
-end