eac_tools 0.103.0 → 0.103.1

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

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

@@ -0,0 +1,54 @@
+# 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/.freeze
+
+        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

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

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

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

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

data/sub/eac_cli/lib/eac_cli/patches/object/runner_with.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Object
+  def runner_with(*runners, &block)
+    include ::EacCli::Runner
+
+    enable_simple_cache
+    enable_speaker
+    runners.each do |runner|
+      include ::EacCli::RunnerWithSet.default.item_to_module(runner)
+    end
+    runner_definition(&block) if block
+  end
+
+  private
+
+  def runner_with_to_module(runner)
+    return runner if runner.is_a?(::Module)
+
+    "EacCli::RunnerWith::#{runner.to_s.camelize}".constantize
+  end
+end

data/sub/eac_cli/lib/eac_cli/patches/object.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir["#{File.dirname(__FILE__)}/#{File.basename(__FILE__, '.*')}/*.rb"].sort.each do |path|
+  require path
+end

data/sub/eac_cli/lib/eac_cli/patches.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+EacRubyUtils.require_sub(__FILE__)

data/sub/eac_cli/lib/eac_cli/rspec/setup.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Rspec
+    module Setup
+      def disable_input_request
+        disable_config_input_request
+        disable_speaker_input_request
+      end
+
+      def disable_config_input_request
+        rspec_config.before do
+          # Fixes EacCli::Config::Entry does not implement #input_value error
+          ::EacCli::Config::Entry.define_method(:input_value) do
+            super
+          end
+          allow_any_instance_of(::EacCli::Config::Entry).to receive(:input_value) do |obj|
+            raise "Console input requested for entry (Path: #{obj.path})"
+          end
+        end
+      end
+
+      def disable_speaker_input_request
+        ::RSpec.configure do |config|
+          config.around do |example|
+            ::EacRubyUtils::Speaker
+              .context.on(::EacCli::Speaker.new(in_in: FailIfRequestInput.new)) { example.run }
+          end
+        end
+      end
+
+      class FailIfRequestInput
+        %w[gets noecho].each do |method|
+          define_method(method) do
+            raise "Input method requested: #{method}. Should not request input on RSpec."
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/rspec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Rspec
+    require_sub __FILE__
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner/after_class_methods.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    module AfterClassMethods
+      # @return [EacCli::Runner::ClassRunner]
+      def class_runner(runner_context_args)
+        ::EacCli::Runner::ClassRunner.new(self, runner_context_args)
+      end
+
+      def create(*runner_context_args)
+        class_runner(runner_context_args).create
+      end
+
+      def run(*runner_context_args)
+        class_runner(runner_context_args).run
+      end
+
+      def runner_definition(&block)
+        @runner_definition ||= super_runner_definition
+        begin
+          @runner_definition.instance_eval(&block) if block
+        rescue ::EacCli::Definition::Error => _e
+          raise ::EacCli::Definition::Error, "Definition error for #{self}"
+        end
+        @runner_definition
+      end
+
+      def super_runner_definition
+        superclass.try(:runner_definition).if_present(&:dup) || ::EacCli::Definition.new
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner/class_runner.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    class ClassRunner
+      PARSER_ERROR_EXIT_CODE = 1
+
+      common_constructor :klass, :context_args
+
+      def create
+        r = klass.new
+        r.runner_context = ::EacCli::Runner::Context.new(r, *context_args)
+        r
+      end
+
+      def run
+        r = create
+        begin
+          r.run_run
+        rescue ::EacCli::Parser::Error => e
+          run_parser_error(r, e)
+        end
+        r
+      end
+
+      def run_parser_error(runner_instance, error)
+        $stderr.write("#{runner_instance.program_name}: #{error}\n")
+        ::Kernel.exit(PARSER_ERROR_EXIT_CODE)
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner/context.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    class Context
+      attr_reader :argv, :parent, :program_name, :runner
+
+      def initialize(runner, *context_args)
+        options = context_args.extract_options!
+        @argv = (context_args[0] || options.delete(:argv) || ARGV).dup.freeze
+        @parent = context_args[1] || options.delete(:parent)
+        @program_name = options.delete(:program_name)
+        @runner = runner
+      end
+
+      # Call a method in the runner or in one of it ancestors.
+      def call(method_name, *args, &block)
+        context_call_responder(method_name).call(*args, &block)
+      end
+
+      # @return [EacCli::Runner::ContextResponders]
+      def context_call_responder(method_name)
+        ::EacCli::Runner::ContextResponders::Set.new(self, method_name, %i[runner parent])
+      end
+
+      # @param method_name [Symbol]
+      # @return [EacCli::Runner::ContextResponders::Parent]
+      def runner_missing_method_responder(method_name)
+        ::EacCli::Runner::ContextResponders::RunnerMissingMethod
+          .new(self, method_name)
+      end
+
+      # @param method_name [Symbol]
+      # @return [Boolean]
+      def parent_respond_to?(method_name)
+        parent.if_present(false) do |v|
+          next true if v.respond_to?(method_name)
+
+          v.if_respond(:runner_context, false) { |w| w.parent_respond_to?(method_name) }
+        end
+      end
+
+      def parent_call(method_name, *args, &block)
+        return parent.runner_context.call(method_name, *args, &block) if
+          parent.respond_to?(:runner_context)
+
+        raise "Parent #{parent} do not respond to .context or .runner_context (Runner: #{runner})"
+      end
+
+      # @param method_name [Symbol]
+      # @return [EacCli::Runner::ContextResponders::Parent]
+      def parent_responder(method_name)
+        ::EacCli::Runner::ContextResponders::Parent.new(self, method_name)
+      end
+    end
+  end
+end