eac_tools 0.117.5 → 0.119.0

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

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

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

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

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Parser
-    class Alternative
-      module LongOptions
-        LONG_OPTION_PREFIX = '--'
-        OPTION_WITH_ARGUMENT_PATTERN = /\A([^=]+)(?:=(.*))\z/
-
-        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

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

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

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

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

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Parser
-    class Alternative
-      module ShortOptions
-        SHORT_OPTION_PREFIX = '-'
-        SHORT_OPTION_CHAR_PATTERN = /\A[0-9a-zA-Z]\z/
-
-        private
-
-        # @return [Boolean]
-        def argv_current_short_option?
-          phase == PHASE_ANY && argv_enum.peek.start_with?(SHORT_OPTION_PREFIX) &&
-            !argv_current_long_option?
-        end
-
-        # @para char [String]
-        # @return [EacCli::Definition::Option, nil]
-        def find_short_option(char)
-          alternative.options.find do |option|
-            short_without_prefix(option.short).if_present(false) { |v| v == char }
-          end
-        end
-
-        # @return [void]
-        def short_option_collect_argv_value
-          last_option = nil
-          short_without_prefix(argv_enum.peek).each_char do |char|
-            raise_error "Invalid option: \"#{char}\"" unless SHORT_OPTION_CHAR_PATTERN.match?(char)
-            raise_error "Option \"#{last_option}\" requires a argument not provided" if
-            last_option.present?
-
-            collected_option = short_option_collect_char(char)
-            last_option = collected_option if collected_option.argument?
-          end
-        end
-
-        # @param char [String]
-        # @return [EacCli::Definition::Option] The option collected.
-        def short_option_collect_char(char)
-          option = find_short_option(char)
-          option ? option_collect_option(option) : any_option_collect_option
-        end
-
-        # @param short [String]
-        # @return [String]
-        def short_without_prefix(short)
-          short.to_s.gsub(/\A#{::Regexp.quote(SHORT_OPTION_PREFIX)}/, '')
-        end
-      end
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Parser
-    class Alternative
-      require_sub __FILE__, include_modules: true
-      enable_listable
-      lists.add_symbol :phase, :any, :option_argument, :positional
-
-      # @return [EacCli::Parser::Error, nil]
-      attr_reader :error
-
-      # @!method initialize(alternative, argv)
-      # @param alternative [EacCli::Definition::Alternative]
-      # @param argv [Array<String>]
-      common_constructor :alternative, :argv do
-        alternative.assert_argument(::EacCli::Definition::Alternative, :alternative)
-        self.phase = PHASE_ANY
-        collect
-      end
-
-      # @return [Boolean]
-      def error?
-        error.present?
-      end
-
-      # @return [Boolean]
-      def success?
-        !error?
-      end
-
-      # @return [EacRubyUtils::Struct]
-      def parsed
-        @parsed ||= collector.to_data.freeze
-      end
-
-      private
-
-      # @return [Symbol]
-      attr_accessor :phase
-
-      # @return [void]
-      def any_collect_argv_value
-        %w[double_dash long_option short_option].each do |arg_type|
-          return send("#{arg_type}_collect_argv_value") if send("argv_current_#{arg_type}?")
-        end
-
-        positional_collect_argv_value
-      end
-
-      # @return [EacCli::Parser::Collector]
-      def collector
-        @collector ||= ::EacCli::Parser::Collector.new(alternative)
-      end
-
-      # @return [void]
-      def collect
-        loop do
-          break unless argv_pending?
-
-          collect_argv_value
-        end
-        validate
-      rescue ::EacCli::Parser::Error => e
-        @error = e
-      end
-
-      # @return [void]
-      def collect_argv_value
-        send("#{phase}_collect_argv_value")
-        argv_enum.next
-      end
-
-      # @param message [String]
-      # @raise [EacCli::Parser::Error] Always.
-      def raise_error(message)
-        raise ::EacCli::Parser::Error.new(alternative, argv, message)
-      end
-
-      # @return [void]
-      # @raise [EacCli::Parser::Error] If options where not properly supplied.
-      def validate
-        (alternative.options + alternative.positional).each do |option|
-          validate_option(option)
-        end
-      end
-
-      # @param option [EacCli::Definition::Option, EacCli::Definition::Positional]
-      # @return [void]
-      # @raise [EacCli::Parser::Error] If option was not properly supplied.
-      def validate_option(option)
-        return unless option.required?
-        return if collector.supplied?(option)
-
-        raise_error("Required option/positional #{option} not supplied")
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/parser/collector.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Parser
-    class Collector
-      class << self
-        def to_data(definition)
-          collector = new(definition)
-          yield(collector)
-          collector.to_data
-        end
-      end
-
-      # @!method initialize(definition)
-      # @param definition [EacCli::Definition]
-      common_constructor :definition do
-        default_values
-      end
-
-      # @return [EacRubyUtils::Struct]
-      def to_data
-        ::EacRubyUtils::Struct.new(data.transform_keys(&:identifier))
-      end
-
-      # @param option [EacCli::Definition::Option]
-      # @param value [String]
-      # @return [void]
-      def collect(option, value)
-        data[option] = option.build_value(value, data[option])
-      end
-
-      # @param option [EacCli::Definition::Option]
-      # @return [Boolean]
-      def supplied?(option)
-        data[option].present?
-      end
-
-      private
-
-      # @return [Hash]
-      def data
-        @data ||= {}
-      end
-
-      # @return [void]
-      def default_values
-        definition.options.each { |option| data[option] = option.default_value }
-        definition.positional.each { |positional| data[positional] = positional.default_value }
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Parser
-    class Error < ::StandardError
-      def initialize(definition, argv, message)
-        @definition = definition
-        @argv = argv
-        super(message)
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Parser
-    enable_simple_cache
-    common_constructor :definition, :argv
-
-    private
-
-    def parsed_uncached
-      raise 'Definition has no alternatives' if alternatives.empty?
-      raise first_error unless alternatives.any?(&:success?)
-
-      alternatives_parsed(true).merge(alternatives_parsed(false))
-    end
-
-    def alternatives_parsed(error)
-      alternatives.select { |a| error == a.error? }.map(&:parsed).reverse
-        .inject(::EacRubyUtils::Struct.new) { |a, e| a.merge(e) }
-    end
-
-    def alternatives_uncached
-      definition.alternatives
-        .map { |alternative| ::EacCli::Parser::Alternative.new(alternative, argv) }
-    end
-
-    def first_error_uncached
-      alternatives.lazy.select(&:error?).map(&:error).first
-    end
-  end
-end