eac_tools 0.105.0 → 0.105.1

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Definition
+    # @abstract
+    class Option < ::EacCli::Definition::OptionOrPositional
+      require_sub __FILE__
+
+      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

@@ -0,0 +1,41 @@
+# 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(*args)
+        ::Kernel.raise ::EacCli::Definition::Error, *args
+      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

@@ -0,0 +1,50 @@
+# 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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Definition
+    require_sub __FILE__
+
+    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, &block)
+      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(&block)
+      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

@@ -0,0 +1,44 @@
+# 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

@@ -0,0 +1,76 @@
+# 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

@@ -0,0 +1,14 @@
+# 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

@@ -0,0 +1,42 @@
+# 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

@@ -0,0 +1,23 @@
+# 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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module EacCli
+  class OldConfigs
+    require_sub __FILE__
+    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

data/sub/eac_cli/lib/eac_cli/parser/alternative/any_options.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module AnyOptions
+        delegate :any_option?, to: :alternative
+
+        # @return [EacCli::Definition::BooleanOption] if #any_option? is true.
+        # @raise [EacCli::Parser::Error] if #any_option? is false.
+        def any_option_collect_option
+          any_option? ? alternative.any_options_option : raise_argv_current_invalid_option
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/parser/alternative/argv.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module Argv
+        # @return [Enumerator<String>]
+        def argv_enum
+          @argv_enum ||= argv.each
+        end
+
+        # @return [Boolean]
+        def argv_pending?
+          argv_enum.ongoing?
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/parser/alternative/double_dash.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module DoubleDash
+        DOUBLE_DASH = '--'
+
+        private
+
+        attr_accessor :double_dash
+
+        def argv_current_double_dash?
+          argv_enum.peek == DOUBLE_DASH && !double_dash
+        end
+
+        def double_dash_collect_argv_value
+          self.phase = PHASE_POSITIONAL
+          self.double_dash = true
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/parser/alternative/long_options.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module LongOptions
+        LONG_OPTION_PREFIX = '--'
+        OPTION_WITH_ARGUMENT_PATTERN = /\A([^=]+)(?:=(.*))\z/.freeze
+
+        private
+
+        def argv_current_long_option?
+          phase == PHASE_ANY && argv_enum.peek.start_with?(LONG_OPTION_PREFIX) &&
+            !argv_current_double_dash?
+        end
+
+        def long_option_collect_argv_value
+          option_long, value = parse_option_current_argv
+          alternative.options.any? do |option|
+            next false unless option.long == option_long
+
+            if value.nil?
+              option_collect_option(option)
+            else
+              option_argument_collect(option, value)
+            end
+          end || any_option_collect_option
+        end
+
+        def parse_option_current_argv
+          m = OPTION_WITH_ARGUMENT_PATTERN.match(argv_enum.peek)
+          m ? [m[1], m[2].if_present('')] : [argv_enum.peek, nil]
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/parser/alternative/option_argument.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module OptionArgument
+        private
+
+        attr_accessor :argument_option
+
+        def argument_option_collect_argv(option)
+          self.argument_option = option
+          self.phase = PHASE_OPTION_ARGUMENT
+        end
+
+        def option_argument_collect(option, value)
+          collector.collect(option, value)
+          self.argument_option = nil
+          self.phase = PHASE_ANY
+          option
+        end
+
+        def option_argument_collect_argv_value
+          option_argument_collect(argument_option, argv_enum.peek)
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/parser/alternative/options.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module Options
+        private
+
+        def boolean_option_collect_argv(option)
+          collector.collect(option, true)
+        end
+
+        def option_collect_option(option)
+          if option.argument?
+            argument_option_collect_argv(option)
+          else
+            boolean_option_collect_argv(option)
+          end
+
+          option
+        end
+
+        def raise_argv_current_invalid_option
+          raise_error "Invalid option: \"#{argv_enum.peek}\""
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/parser/alternative/positionals.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module Positionals
+        private
+
+        def positional_collect_argv_value
+          positional_check
+          collector.collect(positional_enum.peek, argv_enum.peek)
+          positional_next
+        end
+
+        def positional_enum
+          @positional_enum ||= alternative.positional.each
+        end
+
+        def positional_check
+          raise_error("Invalid positional: #{argv_enum.peek}") if positional_enum.stopped?
+        end
+
+        def positional_next
+          self.phase = PHASE_POSITIONAL if positional_enum.peek.subcommand?
+          positional_enum.next unless positional_enum.peek.repeat?
+        end
+      end
+    end
+  end
+end