eac_tools 0.117.5 → 0.118.0

data/sub/eac_cli/lib/eac_cli/definition/alternative.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Definition
-    class Alternative
-      ANY_OPTION_DESCRIPTION = 'ANY_OPTION'
-      ANY_OPTION_LONG = '__'
-      ANY_OPTION_SHORT = '_'
-      SUBCOMMAND_NAME_ARG = :subcommand
-      SUBCOMMAND_ARGS_ARG = :subcommand_args
-
-      # @return [Boolean]
-      def any_opt
-        @any_opt = true
-      end
-
-      # @return [Boolean]
-      def any_option?
-        @any_opt ? true : false
-      end
-
-      # @return [EacCli::Definition::BooleanOption]
-      def any_options_option
-        @any_options_option ||= ::EacCli::Definition::BooleanOption.new(
-          ANY_OPTION_SHORT, ANY_OPTION_LONG, ANY_OPTION_DESCRIPTION,
-          optional: true, repeat: true, usage: false
-        )
-      end
-
-      def arg_opt(*args)
-        options_set << ::EacCli::Definition::ArgumentOption.from_args(args)
-      end
-
-      def bool_opt(*args)
-        options_set << ::EacCli::Definition::BooleanOption.from_args(args)
-      end
-
-      def options
-        options_set.to_a
-      end
-
-      def options_argument?
-        @options_argument ? true : false
-      end
-
-      def options_argument(enable)
-        @options_argument = enable
-
-        self
-      end
-
-      def pos_arg(name, arg_options = {})
-        new_pos_arg = ::EacCli::Definition::Positional.new(name, arg_options)
-        check_positional_blocked(new_pos_arg)
-        pos_set << new_pos_arg
-      end
-
-      def positional
-        pos_set.to_a
-      end
-
-      def positional_arguments_blocked_reason(new_pos_arg)
-        last = pos_set.last
-        return nil unless last
-        return 'there are subcommands' if subcommands?
-        return 'last argument repeats' if last.repeat?
-        return 'new argument is required and last is optional' if
-        last.optional? && new_pos_arg.if_present(&:required?)
-
-        nil
-      end
-
-      def subcommands
-        pos_arg(SUBCOMMAND_NAME_ARG, subcommand: true)
-        pos_set << ::EacCli::Definition::Positional.new(SUBCOMMAND_ARGS_ARG,
-                                                        optional: true, repeat: true)
-      end
-
-      def subcommands?
-        pos_set.any?(&:subcommand?)
-      end
-
-      private
-
-      def check_positional_blocked(new_pos_arg)
-        positional_arguments_blocked_reason(new_pos_arg).if_present do |v|
-          raise ::EacCli::Definition::Error, "Positional arguments are blocked: #{v} " \
-                                             "(New argument: #{new_pos_arg})"
-        end
-      end
-
-      def pos_set
-        @pos_set ||= []
-      end
-
-      def options_set
-        @options_set ||= []
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/definition/argument_option.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Definition
-    class ArgumentOption < ::EacCli::Definition::Option
-      def argument?
-        true
-      end
-
-      def build_value(new_value, previous_value)
-        repeat? ? previous_value + [new_value] : new_value
-      end
-
-      def default_default_value
-        repeat? ? [] : nil
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/definition/boolean_option.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Definition
-    class BooleanOption < ::EacCli::Definition::Option
-      def argument?
-        false
-      end
-
-      def build_value(_new_value, previous_value)
-        repeat? ? previous_value + 1 : true
-      end
-
-      def default_value
-        return super unless default_value?
-
-        raise("Unallowed default value for boolean options (Option: #{self})")
-      end
-
-      def default_default_value
-        repeat? ? 0 : false
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/definition/error.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Definition
-    class Error < ::StandardError
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/definition/option/initialize_args_parser.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Definition
-    class Option
-      class InitializeArgsParser
-        PROPERTIES = %i[short long description options].freeze
-        attr_reader(*PROPERTIES)
-
-        def initialize(args)
-          self.options = args.extract_options!.freeze
-          args.each { |arg| absorb_arg(arg) }
-        end
-
-        private
-
-        attr_writer(*PROPERTIES)
-
-        def absorb_arg(arg)
-          arg_ext = ArgumentParser.new(arg)
-          send("#{arg_ext.type}=", arg_ext.value)
-        end
-
-        class ArgumentParser
-          TYPES = %i[short long description].freeze
-          common_constructor :value
-
-          def type
-            TYPES.find { |type| send("#{type}?") } ||
-              raise(::EacCli::Definition::Error, "Unknown type for \"#{value}\"")
-          end
-
-          def short?
-            value.start_with?('-') && !long?
-          end
-
-          def long?
-            value.start_with?('--')
-          end
-
-          def description?
-            !short? || !long?
-          end
-        end
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/definition/option.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Definition
-    # @abstract
-    class Option < ::EacCli::Definition::OptionOrPositional
-      class << self
-        # @param args [Enumerable<String>]
-        # @return [EacCli::Definition::Option]
-        def from_args(args)
-          p = ::EacCli::Definition::Option::InitializeArgsParser.new(args)
-          new(p.short, p.long, p.description, p.options)
-        end
-      end
-
-      DEFAULT_REQUIRED = false
-
-      enable_abstract_methods
-      lists.add_symbol :option, *OPTION_LIST, :default, :usage
-
-      # @!method initialize(short, long, description, options = {})
-      # @param short [String]
-      # @param long [String]
-      # @param description [String]
-      # @param options [Hash<Symbol, Object>]
-      # @raise [EacCli::Definition::Error]
-      common_constructor :short, :long, :description, :options, default: [{}] do
-        validate
-        self.options = ::EacCli::Definition::Option.lists.option.hash_keys_validate!(
-          options.symbolize_keys
-        )
-      end
-
-      # @return [Object]
-      def default_value
-        default_value? ? options[OPTION_DEFAULT] : default_default_value
-      end
-
-      # @return [Boolean]
-      def default_value?
-        options.key?(OPTION_DEFAULT)
-      end
-
-      # @return [Symbol]
-      # @raise [EacCli::Definition::Error] If no short or long option is provided.
-      def identifier
-        [long, short].each do |v|
-          v.to_s.if_present { |vv| return vv.variableize.to_sym }
-        end
-
-        raise('No short or long option to build identifier')
-      end
-
-      # @return [Boolean]
-      def show_on_usage?
-        options[:usage]
-      end
-
-      private
-
-      # @return [void]
-      # @raise [EacCli::Definition::Error]
-      def validate
-        raise 'Nor short neither long selector was set' if short.blank? && long.blank?
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/definition/option_or_positional.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Definition
-    # @abstract
-    class OptionOrPositional
-      acts_as_abstract :build_value, :default_value, :identifier, :options
-      enable_listable
-
-      OPTION_LIST = %i[optional repeat required].freeze
-
-      # @return [Boolean]
-      def optional?
-        !required?
-      end
-
-      # @raise [EacCli::Definition::Error]
-      def raise(*)
-        ::Kernel.raise(::EacCli::Definition::Error, *)
-      end
-
-      # @return [Boolean]
-      def repeat?
-        options[:repeat] ? true : false
-      end
-
-      # @return [Boolean]
-      def required?
-        return true if options.key?(:required) && options.fetch(:required)
-        return false if options.key?(:optional) && options.fetch(:optional)
-
-        self.class.const_get('DEFAULT_REQUIRED')
-      end
-
-      # @return [String]
-      def to_s
-        "#{self.class.name.demodulize}[#{identifier}]"
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/definition/positional.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Definition
-    class Positional < ::EacCli::Definition::OptionOrPositional
-      DEFAULT_REQUIRED = true
-      DEFAULT_VISIBLE = true
-
-      lists.add_symbol :option, *OPTION_LIST, :subcommand, :visible
-
-      # @!method initialize(name, options = {})
-      # @param name [String]
-      # @param options [Hash<Symbol, Object>]
-      common_constructor :name, :options, default: [{}] do
-        options.assert_valid_keys(self.class.lists.option.values)
-      end
-
-      # @param new_value [Array, Object]
-      # @param previous_value [Array, Object]
-      # @return [Array]
-      def build_value(new_value, previous_value)
-        if previous_value.is_a?(::Array)
-          previous_value + [new_value]
-        else
-          new_value
-        end
-      end
-
-      # @return [Object]
-      def default_value
-        repeat? ? [] : nil
-      end
-
-      # @return [Symbol]
-      def identifier
-        name.to_s.variableize.to_sym
-      end
-
-      # @return [Boolean]
-      def subcommand?
-        options[OPTION_SUBCOMMAND]
-      end
-
-      # @return [Boolean]
-      def visible?
-        options.key?(OPTION_VISIBLE) ? options.fetch(OPTION_VISIBLE) : DEFAULT_VISIBLE
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/definition.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Definition
-    MAIN_ALTERNATIVE_KEY = :main
-    SUBCOMMAND_NAME_ARG = 'subcommand'
-    SUBCOMMAND_ARGS_ARG = 'subcommand_args'
-
-    # @return [String, nil]
-    attr_accessor :description
-
-    def initialize
-      self.description = '-- NO DESCRIPTION SET --'
-      alternatives_set[MAIN_ALTERNATIVE_KEY] = main_alternative
-    end
-
-    # @return [EacCli::Definition::Alternative]
-    def alt(key = nil, &)
-      key ||= new_alternative_key
-      raise(::EacCli::Definition::Error, "A alternative with key=\"#{key}\" already exists") if
-        key.present? && alternatives_set.key?(key)
-
-      r = ::EacCli::Definition::Alternative.new
-      r.instance_eval(&)
-      alternatives_set[key] = r
-      r
-    end
-
-    # @return [Enumerable<EacCli::Definition::Alternative>]
-    def alternatives
-      alternatives_set.values
-    end
-
-    # @return [EacCli::Definition::Alternative]
-    # @raise [KeyError] If there is not a alternative with provided key.
-    def alternative(key)
-      alternatives_set.fetch(key)
-    end
-
-    # Same as {#description=}.
-    def desc(description)
-      self.description = description
-    end
-
-    # @return [EacCli::Definition::Alternative]
-    def main_alternative
-      @main_alternative ||= begin
-        r = ::EacCli::Definition::Alternative.new
-        r.options_argument(true)
-        r
-      end
-    end
-
-    # Same as {#options_argument=}.
-    # @param options_argument [Boolean]
-    def options_arg(options_argument)
-      self.options_argument = options_argument
-    end
-
-    # @return [Boolean]
-    def options_argument # rubocop:disable Naming/PredicateMethod
-      main_alternative.options_argument?
-    end
-
-    def options_argument=(enable)
-      main_alternative.options_argument(enable)
-    end
-
-    delegate :arg_opt, :bool_opt, :options, :pos_arg,
-             :positional, :subcommands, to: :main_alternative
-
-    def subcommands?
-      alternatives.any?(&:subcommands?)
-    end
-
-    def options_first(enable = true) # rubocop:disable Style/OptionalBooleanParameter
-      @options_first = enable
-    end
-
-    def options_first?
-      @options_first ? true : false
-    end
-
-    private
-
-    def alternatives_set
-      @alternatives_set ||= ::ActiveSupport::HashWithIndifferentAccess.new
-    end
-
-    def new_alternative_key
-      @last_key ||= 0
-      loop do
-        @last_key += 1
-        break @last_key unless alternatives_set.key?(@last_key)
-      end
-    end
-
-    def pos_set
-      @pos_set ||= []
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/enum.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require 'colorized_string'
-
-module EacCli
-  # A [EacRubyUtils::Enum] which each value is associated with one console color.
-  class Enum < ::EacRubyUtils::Enum
-    # Foreground color used in [to_bg_label]
-    TO_BG_LABEL_FG_COLOR = :light_white
-
-    attr_reader :color
-
-    def initialize(key, color)
-      super(key)
-      @color = color
-    end
-
-    delegate :to_s, to: :key
-
-    # @return [String]
-    def to_label
-      to_fg_label
-    end
-
-    # @return [String]
-    def to_fg_label
-      to_fg_bg_label(color)
-    end
-
-    # @return [String]
-    def to_bg_label
-      to_fg_bg_label(TO_BG_LABEL_FG_COLOR, color)
-    end
-
-    private
-
-    # @return [String]
-    def to_fg_bg_label(fg_color, bg_color = nil)
-      colors = { color: fg_color }
-      bg_color.if_present { |v| colors[:background] = v }
-      ::ColorizedString[to_s].colorize(colors)
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/old_configs/entry_reader.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class OldConfigs
-    class EntryReader
-      enable_speaker
-
-      class << self
-        def entry_key_to_envvar_name(entry_key)
-          path = if entry_key.is_a?(::Array)
-                   entry_key
-                 else
-                   ::EacConfig::PathsHash.parse_entry_key(entry_key)
-                 end
-          path.join('_').gsub(/[^a-z0-9_]/i, '').gsub(/\A_+/, '').gsub(/_+\z/, '')
-            .gsub(/_{2,}/, '_').upcase
-        end
-      end
-
-      common_constructor :console_configs, :entry_key, :options do
-        self.options = ::EacCli::OldConfigs::ReadEntryOptions.new(options)
-      end
-
-      def read
-        %w[envvars storage console].each do |suffix|
-          value = send("read_from_#{suffix}")
-          return value if value.present?
-        end
-        return nil unless options[:required]
-
-        raise "No value found for entry \"#{entry_key}\""
-      end
-
-      def read_from_storage
-        console_configs.configs.read_entry(entry_key)
-      end
-
-      def read_from_envvars
-        return if options[:noenv]
-
-        env_entry_key = self.class.entry_key_to_envvar_name(entry_key)
-        return unless ENV.key?(env_entry_key)
-
-        ENV.fetch(env_entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
-      end
-
-      def read_from_console
-        return if options[:noinput]
-
-        options[:before_input].if_present(&:call)
-        entry_value = looped_entry_value_from_input
-        console_configs.configs.write_entry(entry_key, entry_value) if options[:store]
-        entry_value
-      end
-
-      private
-
-      def looped_entry_value_from_input
-        loop do
-          entry_value = entry_value_from_input(entry_key, options)
-          next if entry_value.blank?
-          next if options[:validator] && !options[:validator].call(entry_value)
-
-          return entry_value
-        end
-      end
-
-      def entry_value_from_input(entry_key, options)
-        entry_value = input("Value for entry \"#{entry_key}\"",
-                            options.request_input_options)
-        warn('Entered value is blank') if entry_value.blank?
-        entry_value
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/old_configs/password_entry_reader.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class OldConfigs
-    class PasswordEntryReader < ::EacCli::OldConfigs::EntryReader
-      ENTRY_KEY = 'core.store_passwords'
-
-      def initialize(console_configs, entry_key, options = {})
-        super(console_configs, entry_key, options.merge(noecho: true,
-                                                        store: console_configs.store_passwords?))
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/old_configs/read_entry_options.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class OldConfigs
-    class ReadEntryOptions
-      enable_simple_cache
-      common_constructor :options do
-        self.options = options.to_h.symbolize_keys
-                         .assert_valid_keys(DEFAULT_VALUES.keys).freeze
-      end
-
-      DEFAULT_VALUES = {
-        before_input: nil, bool: false, list: false, noecho: false, noenv: false, noinput: false,
-        required: true, store: true, validator: nil
-      }.freeze
-
-      delegate :to_h, to: :options
-
-      def [](key)
-        values.fetch(key.to_sym)
-      end
-
-      def request_input_options
-        values.slice(:bool, :list, :noecho)
-      end
-
-      private
-
-      def values_uncached
-        consumer = options.to_options_consumer
-        r = {}
-        DEFAULT_VALUES.each do |key, default_value|
-          value = consumer.consume(key)
-          value = default_value if value.nil?
-          r[key] = value
-        end
-        consumer.validate
-        r
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/old_configs/store_passwords_entry_reader.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class OldConfigs
-    class StorePasswordsEntryReader < ::EacCli::OldConfigs::EntryReader
-      ENTRY_KEY = 'core.store_passwords'
-
-      def initialize(console_configs)
-        super(console_configs, ENTRY_KEY,
-          before_input: -> { banner },
-          validator: ->(entry_value) { %w[yes no].include?(entry_value) }
-        )
-      end
-
-      def banner
-        infom 'Do you wanna to store passwords?'
-        infom 'Warning: the passwords will be store in clear text in ' \
-              "\"#{console_configs.configs.storage_path}\""
-        infom 'Enter "yes" or "no"'
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/old_configs.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class OldConfigs
-    enable_speaker
-
-    class << self
-      delegate :entry_key_to_envvar_name, to: :'::EacCli::OldConfigs::EntryReader'
-    end
-
-    attr_reader :configs
-
-    def initialize(configs_key, options = {})
-      options.assert_argument(::Hash, 'options')
-      @configs = ::EacConfig::OldConfigs.new(configs_key, options.merge(autosave: true))
-    end
-
-    def read_password(entry_key, options = {})
-      ::EacCli::OldConfigs::PasswordEntryReader.new(self, entry_key, options).read
-    end
-
-    def read_entry(entry_key, options = {})
-      ::EacCli::OldConfigs::EntryReader.new(self, entry_key, options).read
-    end
-
-    def store_passwords?
-      ::EacCli::OldConfigs::StorePasswordsEntryReader.new(self) == 'yes'
-    end
-  end
-end