eac_tools 0.122.0 → 0.123.1

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/base_command/concat.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/struct'
-
-module EacRubyUtils
-  module Envs
-    module BaseCommand
-      module Concat
-        AND_OPERATOR = '&&'
-        BEFORE_OPERATOR = ';'
-        OR_OPERATOR = '||'
-        PIPE_OPERATOR = '|'
-
-        # @param operator [Symbol]
-        # @return [EacRubyUtils::Envs::CompositeCommand]
-        def concat(operator, other_command)
-          require 'eac_ruby_utils/envs/composite_command'
-          ::EacRubyUtils::Envs::CompositeCommand.new(operator, self, other_command)
-        end
-
-        # @return [EacRubyUtils::Envs::Command]
-        def and(other_command)
-          concat(AND_OPERATOR, other_command)
-        end
-
-        # @return [EacRubyUtils::Envs::Command]
-        def before(other_command)
-          concat(BEFORE_OPERATOR, other_command)
-        end
-
-        def or(other_command)
-          concat(OR_OPERATOR, other_command)
-        end
-
-        def pipe(other_command)
-          concat(PIPE_OPERATOR, other_command)
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/base_command/debugging.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  module Envs
-    module BaseCommand
-      module Debugging
-        def debug?
-          ENV['DEBUG'].to_s.strip != ''
-        end
-
-        # Print a message if debugging is enabled.
-        def debug_print(message)
-          message = message.to_s
-          puts message.if_respond(:light_red, message) if debug?
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/base_command/execution.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/envs/execution_error'
-require 'eac_ruby_utils/envs/execution_result'
-require 'eac_ruby_utils/envs/process'
-require 'eac_ruby_utils/envs/spawn'
-require 'pp'
-
-module EacRubyUtils
-  module Envs
-    module BaseCommand
-      module Execution
-        common_concern do
-          include ActiveSupport::Callbacks
-
-          define_callbacks :any_execution, :execute, :spawn, :system
-        end
-
-        def execute!(options = {})
-          options[:exit_outputs] = status_results.merge(options[:exit_outputs].presence || {})
-          er = ::EacRubyUtils::Envs::ExecutionResult.new(execute(options), options)
-          return er.result if er.success?
-
-          raise ::EacRubyUtils::Envs::ExecutionError,
-                "execute! command failed: #{self}\n#{er.r.pretty_inspect}"
-        end
-
-        def execute(options = {})
-          c = command(options)
-          debug_print("BEFORE: #{c}")
-          t1 = Time.now
-          r = run_callbacks :any_execution, :execute do
-            ::EacRubyUtils::Envs::Process.new(c).to_h
-          end
-          i = Time.now - t1
-          debug_print("AFTER [#{i}]: #{c}")
-          r
-        end
-
-        def spawn(options = {})
-          c = command(options)
-          debug_print("SPAWN: #{c}")
-          run_callbacks :any_execution, :spawn do
-            ::EacRubyUtils::Envs::Spawn.new(c)
-          end
-        end
-
-        def system!(options = {})
-          return if system(options)
-
-          raise ::EacRubyUtils::Envs::ExecutionError, "system! command failed: #{self}"
-        end
-
-        def system(options = {})
-          c = command(options)
-          debug_print(c)
-          run_callbacks(:any_execution, :system) { Kernel.system(c) }
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/base_command/extra_options.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/core_ext/object/blank'
-require 'shellwords'
-
-module EacRubyUtils
-  module Envs
-    module BaseCommand
-      module ExtraOptions
-        # @return [ActiveSupport::HashWithIndifferentAccess]
-        def extra_options
-          @extra_options ||= {}.with_indifferent_access
-        end
-
-        def status_result(status_code, result)
-          duplicate_by_extra_options(status_results: status_results.merge(status_code => result))
-        end
-
-        private
-
-        def status_results
-          extra_options[:status_results] ||= {}.with_indifferent_access
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/base_command.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-require 'shellwords'
-
-module EacRubyUtils
-  module Envs
-    module BaseCommand
-      require_sub __FILE__
-
-      common_concern do
-        enable_abstract_methods
-        include ::EacRubyUtils::Envs::BaseCommand::Concat
-        include ::EacRubyUtils::Envs::BaseCommand::Debugging
-        include ::EacRubyUtils::Envs::BaseCommand::Execution
-        include ::EacRubyUtils::Envs::BaseCommand::ExtraOptions
-      end
-
-      # @return [EacRubyUtils::Envs::BaseEnv]
-      def env
-        raise_abstract_method __method__
-      end
-
-      def command(options = {})
-        append_command_options(
-          env.command_line(command_line_without_env),
-          options
-        )
-      end
-
-      # @return [String]
-      def command_line_without_env(_options = {})
-        raise_abstract_method __method__
-      end
-
-      private
-
-      def escape(arg)
-        arg = arg.to_s
-        m = /^@ESC_(.+)$/.match(arg)
-        m ? m[1] : Shellwords.escape(arg)
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/base_env.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/envs/command'
-require 'eac_ruby_utils/envs/executable'
-require 'eac_ruby_utils/envs/file'
-
-module EacRubyUtils
-  module Envs
-    class BaseEnv
-      def command(*args)
-        ::EacRubyUtils::Envs::Command.new(self, args)
-      end
-
-      # <b>DEPRECATED:</b> Please use <tt>file(file).exist?</tt> instead.
-      def file_exist?(file)
-        self.file(file).exist?
-      end
-
-      def executable(*executable_new_args)
-        ::EacRubyUtils::Envs::Executable.new(self, *executable_new_args)
-      end
-
-      def file(path)
-        ::EacRubyUtils::Envs::File.new(self, path)
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/command/envvars.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-require 'shellwords'
-
-module EacRubyUtils
-  module Envs
-    class Command
-      module Envvars
-        def envvar(name, value)
-          duplicate_by_extra_options(envvars: envvars.merge(name => value))
-        end
-
-        private
-
-        def append_envvars(command)
-          e = envvars.map { |k, v| "#{Shellwords.escape(k)}=#{Shellwords.escape(v)}" }.join(' ')
-          e.present? ? "#{e} #{command}" : command
-        end
-
-        def envvars
-          extra_options[:envvars] ||= {}.with_indifferent_access
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/command/extra_options.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/core_ext/object/blank'
-require 'shellwords'
-
-module EacRubyUtils
-  module Envs
-    class Command
-      module ExtraOptions
-        def chdir(dir)
-          duplicate_by_extra_options(chdir: dir)
-        end
-
-        private
-
-        def append_chdir(command)
-          extra_options[:chdir].present? ? "(cd '#{extra_options[:chdir]}' ; #{command} )" : command
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/command.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/envs/base_command'
-
-module EacRubyUtils
-  module Envs
-    class Command
-      require_sub __FILE__, include_modules: true, require_mode: :kernel
-      include ::EacRubyUtils::Envs::BaseCommand
-
-      class << self
-        # @param command [Array]
-        # @return [Array]
-        def sanitize_initialize_arguments(arguments)
-          if arguments.one? && arguments.first.is_a?(Array)
-            arguments.first
-          elsif arguments.is_a?(Array)
-            arguments
-          else
-            raise "Invalid argument command: #{arguments}|#{arguments.class}"
-          end
-        end
-      end
-
-      common_constructor :env, :args, :extra_options, default: [{}] do
-        self.extra_options = extra_options.with_indifferent_access
-        self.args = self.class.sanitize_initialize_arguments(args)
-      end
-
-      def append(args)
-        duplicate_by_command(self.args + args)
-      end
-
-      def prepend(args)
-        duplicate_by_command(args + self.args)
-      end
-
-      def to_s
-        "#{args} [ENV: #{env}]"
-      end
-
-      # @return [String]
-      def command_line_without_env
-        c = args
-        c = c.map { |x| escape(x) }.join(' ') if c.is_a?(Enumerable)
-        append_chdir(append_envvars(c))
-      end
-
-      protected
-
-      def duplicate(command, extra_options)
-        self.class.new(env, command, extra_options)
-      end
-
-      private
-
-      def duplicate_by_command(new_command)
-        duplicate(new_command, extra_options)
-      end
-
-      def duplicate_by_extra_options(set_extra_options)
-        duplicate(args, extra_options.merge(set_extra_options))
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/composite_command.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/envs/base_command'
-
-module EacRubyUtils
-  module Envs
-    class CompositeCommand
-      include ::EacRubyUtils::Envs::BaseCommand
-
-      enable_listable
-      lists.add_string :operator, '&&' => :and, ';' => :before, '||' => :or, '|' => :pipe
-
-      common_constructor :operator, :left_command, :right_command do
-        self.operator = self.class.lists.operator.value_validate!(operator.to_s)
-      end
-
-      # @return [EacRubyUtils::Envs::BaseEnv]
-      delegate :env, to: :left_command
-
-      # @return [String]
-      def command_line_without_env(_options = {})
-        ::Shellwords.join(['bash', '-c', bash_command])
-      end
-
-      # @return [String]
-      def bash_command
-        ['set', '-euo', 'pipefail', OPERATOR_BEFORE, left_command_line, operator,
-         right_command_line].join(' ')
-      end
-
-      def left_command_line
-        left_command.command_line_without_env
-      end
-
-      def right_command_line
-        if right_command.env == left_command.env
-          right_command.command_line_without_env
-        else
-          right_command.command
-        end
-      end
-    end
-  end
-end

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

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/listable'
-require 'memoized'
-
-module EacRubyUtils
-  module Envs
-    class Executable
-      include ::EacRubyUtils::Listable
-      include ::Memoized
-
-      lists.add_symbol :option, :check_args, :exec_args, :auto_validate
-
-      DEFAULT_AUTO_VALIDATE = true
-
-      attr_reader :env, :name, :options
-
-      def initialize(env, name, *check_args)
-        @env = env
-        @name = name
-        self.options = self.class.lists.option.hash_keys_validate!(check_args.extract_options!)
-        options[OPTION_CHECK_ARGS] = check_args unless options.key?(OPTION_CHECK_ARGS)
-        options.freeze
-      end
-
-      def auto_validate?
-        options.key?(OPTION_AUTO_VALIDATE) ? options[OPTION_AUTO_VALIDATE] : DEFAULT_AUTO_VALIDATE
-      end
-
-      def check_args
-        options[OPTION_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! if auto_validate?
-        env.command(*executable_args, *command_args)
-      end
-
-      def executable_args
-        executable_args_from_envvar || executable_args_from_options || executable_args_from_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
-
-      # @return [Enumerable<String>]
-      def executable_args_from_name
-        ::Shellwords.split(name)
-      end
-
-      # @return [Enumerable<String>]
-      def executable_args_from_options
-        options[OPTION_EXEC_ARGS].if_present do |v|
-          v.is_a?(::Enumerable) ? v.map(&:to_s) : ::Shellwords.split(v.to_s)
-        end
-      end
-
-      private
-
-      attr_writer :options
-
-      memoize def exist
-        env.command(*executable_args, *check_args).execute!
-        true
-      rescue Errno::ENOENT
-        false
-      end
-
-      class ProgramNotFoundError < ::StandardError; end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/execution_error.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  module Envs
-    class ExecutionError < ::RuntimeError
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/execution_result.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/envs/execution_error'
-
-module EacRubyUtils
-  module Envs
-    class ExecutionResult
-      attr_reader :r, :options
-
-      def initialize(result, options)
-        @r = result
-        @options = options
-      end
-
-      def result
-        return exit_code_zero_result if exit_code_zero?
-        return expected_error_result if expected_error?
-
-        raise ::EacRubyUtils::Envs::ExecutionError, 'Failed!'
-      end
-
-      def success?
-        exit_code_zero? || expected_error?
-      end
-
-      private
-
-      def exit_code_zero?
-        r[:exit_code]&.zero?
-      end
-
-      def exit_code_zero_result
-        r[options[:output] || :stdout]
-      end
-
-      def expected_error_result
-        options[:exit_outputs][r[:exit_code]]
-      end
-
-      def expected_error?
-        options[:exit_outputs].is_a?(Hash) && options[:exit_outputs].key?(r[:exit_code])
-      end
-    end
-  end
-end

data/sub/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/sub/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/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/process.rb

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

data/sub/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/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/ssh_env/dasho_options.rb

@@ -1,51 +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
-
-          delegate :nodasho_options, to: :class
-
-          def uri_query_value(name)
-            uri.query_values.if_present { |v| v[name] }
-          end
-        end
-      end
-    end
-  end
-end