eac_tools 0.104.0 → 0.105.1

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/{avm-git/lib/avm/git/issue.rb → eac_cli/lib/eac_cli/patches.rb}

@@ -1,10 +1,3 @@
 # frozen_string_literal: true
 
 EacRubyUtils.require_sub(__FILE__)
-
-module Avm
-  module Git
-    module Issue
-    end
-  end
-end

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/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

data/sub/eac_cli/lib/eac_cli/runner/context_responders/base.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    module ContextResponders
+      class Base
+        acts_as_abstract :call, :callable?
+        common_constructor :context, :method_name do
+          self.method_name = method_name.to_sym
+        end
+        delegate :parent, :runner, to: :context
+
+        def if_callable # rubocop:disable Naming/PredicateMethod
+          return false unless callable?
+
+          yield(self)
+          true
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner/context_responders/parent.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    module ContextResponders
+      class Parent < ::EacCli::Runner::ContextResponders::Base
+        def callable?
+          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 call(*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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    module ContextResponders
+      class Runner < ::EacCli::Runner::ContextResponders::Base
+        def callable?
+          runner.respond_to?(method_name)
+        end
+
+        def call(*args, &block)
+          runner.send(method_name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner/context_responders/runner_missing_method.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    module ContextResponders
+      class RunnerMissingMethod < ::EacCli::Runner::ContextResponders::Base
+        def callable?
+          responder_runner.present?
+        end
+
+        def call(*args, &block)
+          responder_runner.send(method_name, *args, &block)
+        end
+
+        private
+
+        def responder_runner
+          parent.if_present(nil) do |v|
+            next v if v.respond_to?(method_name) && v.for_context?(method_name)
+
+            v.if_respond(:runner_context, nil) do |w|
+              w.runner_missing_method_responder(method_name).send(__method__)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner/context_responders/set.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    module ContextResponders
+      class Set < ::EacCli::Runner::ContextResponders::Base
+        attr_reader :responders_names
+
+        def initialize(context, method_name, responders_names)
+          super(context, method_name)
+          @responders_names = responders_names
+        end
+
+        def callable?
+          responders_instances.any?(&:callable?)
+        end
+
+        def call(...)
+          caller = responder_to_call
+          return caller.call(...) if caller
+
+          raise ::NameError, "No method \"#{method_name}\" found in #{runner} or in its ancestors"
+        end
+
+        private
+
+        def responder_class(class_name)
+          ::EacCli::Runner::ContextResponders.const_get(class_name.to_s.camelize)
+        end
+
+        def responders_instances
+          responders_names.lazy.map { |name| responder_class(name).new(context, method_name) }
+        end
+
+        def responder_to_call
+          responders_instances.lazy.select(&:callable?).first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    class Exit < ::StandardError
+      attr_reader :status
+
+      def initialize(status = true) # rubocop:disable Style/OptionalBooleanParameter
+        super
+        @status = status
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    module ForContext
+      common_concern
+
+      module ClassMethods
+        # @param methods_names [Enumerable<Symbol>]
+        # @return [void]
+        def for_context(*methods_names)
+          for_context_methods.merge(methods_names.map(&:to_sym))
+        end
+
+        # @param method_name [Symbol]
+        # @return [Boolean]
+        def for_context?(method_name)
+          for_context_methods.include?(method_name.to_sym)
+        end
+
+        private
+
+        # @return [EacRubyUtils::ModuleAncestorsVariable::Set<Symbol>]
+        def for_context_methods
+          @for_context_methods ||=
+            ::EacRubyUtils::ModuleAncestorsVariable::Set.new(self, __method__)
+        end
+      end
+
+      # @param method_name [Symbol]
+      # @return [Boolean]
+      delegate :for_context?, to: :class
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    module InstanceMethods
+      def run_run
+        parsed
+        run_callbacks(:run) { run }
+      rescue ::EacCli::Runner::Exit
+        # Do nothing
+      end
+
+      def runner_context
+        return @runner_context if @runner_context
+
+        raise 'Context was required, but was not set yet'
+      end
+
+      def runner_context=(new_runner_context)
+        @runner_context = new_runner_context
+        @parsed = nil
+      end
+
+      def parsed
+        @parsed ||= ::EacCli::Parser.new(self.class.runner_definition, runner_context.argv).parsed
+      end
+
+      def program_name
+        runner_context.if_present(&:program_name) || $PROGRAM_NAME
+      end
+
+      def respond_to_missing?(method, include_all = false)
+        runner_context.runner_missing_method_responder(method).callable? || super
+      end
+
+      def method_missing(method, *args, &block)
+        runner_context.runner_missing_method_responder(method).if_callable do |v|
+          return v.call(*args, &block)
+        end
+
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    require_sub __FILE__
+    extend ::ActiveSupport::Concern
+
+    class << self
+      def alias_runner_class_methods(klass, from_suffix, to_suffix)
+        %i[create run].each do |method|
+          alias_class_method(klass, build_method_name(method, from_suffix),
+                             build_method_name(method, to_suffix))
+        end
+      end
+
+      def runner?(object)
+        object.is_a?(::Class) && object.included_modules.include?(::EacCli::Runner)
+      end
+
+      private
+
+      def alias_class_method(klass, from, to)
+        sklass = klass.singleton_class
+        return unless sklass.method_defined?(from)
+
+        sklass.send(:alias_method, to, from)
+      end
+
+      def build_method_name(name, suffix)
+        ss = suffix.if_present('') { |s| "#{s}_" }
+        "#{ss}#{name}"
+      end
+    end
+
+    the_module = self
+    included do
+      the_module.alias_runner_class_methods(self, '', 'original')
+
+      extend AfterClassMethods
+      include InstanceMethods
+      include ::EacCli::Runner::ForContext
+      include ActiveSupport::Callbacks
+
+      define_callbacks :run
+    end
+  end
+end