ehbrs-tools 0.13.1 → 0.16.1

data/vendor/eac_cli/lib/eac_cli/parser/parse_result.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'eac_cli/parser/error'
 require 'eac_ruby_utils/core_ext'
 
 module EacCli
@@ -8,6 +9,20 @@ module EacCli
       common_constructor :definition, :argv
 
       def result
+        result_or_error = parse(definition)
+        return result_or_error unless result_or_error.is_a?(::Exception)
+
+        definition.alternatives.each do |alternative|
+          alt_result_or_error = parse(alternative)
+          return alt_result_or_error unless alt_result_or_error.is_a?(::Exception)
+        end
+
+        raise result_or_error
+      end
+
+      private
+
+      def parse(definition)
         ::EacCli::Parser::Collector.to_data(definition) do |collector|
           ::EacCli::Parser::PositionalCollection.new(
             definition,
@@ -15,6 +30,8 @@ module EacCli
             collector
           )
         end
+      rescue ::EacCli::Parser::Error => e
+        e
       end
     end
   end

data/vendor/eac_cli/lib/eac_cli/parser/positional_collection.rb

@@ -10,39 +10,67 @@ module EacCli
 
       private
 
+      def argv_enum
+        @argv_enum ||= argv.each
+      end
+
+      def argv_pending?
+        argv_enum.ongoing?
+      end
+
+      def argv_pending_check
+        return unless argv_pending?
+        return unless positional_enum.stopped?
+
+        raise ::EacCli::Parser::Error.new(
+          definition, argv, "No positional left for argv \"#{argv_enum.current}\""
+        )
+      end
+
       def collected
         @collected ||= ::Set.new
       end
 
       def collect
-        argv.each { |argv_value| colect_argv_value(argv_value) }
-        return unless pending_required_positional?
+        loop do
+          break unless enums('pending?').any?
 
-        raise ::EacCli::Parser::Error.new(
-          definition, argv, 'No value for required positional ' \
-            "\"#{current_positional.identifier}\""
-        )
+          enums('pending_check')
+          collect_argv_value
+        end
+      end
+
+      def collect_argv_value
+        collector.collect(*enums('enum', &:peek))
+        collected << positional_enum.peek
+        positional_enum.next unless positional_enum.peek.repeat?
+        argv_enum.next
       end
 
-      def colect_argv_value(argv_value)
-        collector.collect(current_positional, argv_value)
-        collected << current_positional
-        positional_enumerator.next unless current_positional.repeat?
+      def enums(method_suffix, &block)
+        %w[positional argv].map do |method_prefix|
+          v = send("#{method_prefix}_#{method_suffix}")
+          block ? block.call(v) : v
+        end
       end
 
-      def pending_required_positional?
-        !(current_positional.blank? || current_positional.optional? ||
-            collected.include?(current_positional))
+      def positional_enum
+        @positional_enum ||= definition.positional.each
       end
 
-      def positional_enumerator
-        @positional_enumerator ||= definition.positional.each
+      def positional_pending?
+        !(positional_enum.stopped? || positional_enum.current.optional? ||
+            collected.include?(positional_enum.current))
       end
 
-      def current_positional
-        positional_enumerator.peek
-      rescue ::StopIteration
-        nil
+      def positional_pending_check
+        return unless positional_pending?
+        return unless argv_enum.stopped?
+
+        raise ::EacCli::Parser::Error.new(
+          definition, argv, 'No value for required positional ' \
+            "\"#{positional_enum.current.identifier}\""
+        )
       end
     end
   end

data/vendor/eac_cli/lib/eac_cli/patches.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+::EacRubyUtils.require_sub(__FILE__)

data/vendor/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/vendor/eac_cli/lib/eac_cli/patches/object/runner_with.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_cli/runner'
+require 'eac_cli/runner_with'
+
+class Object
+  def runner_with(*runners, &block)
+    include ::EacCli::Runner
+    enable_simple_cache
+    enable_console_speaker
+    runners.each do |runner|
+      include runner_with_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/vendor/eac_cli/lib/eac_cli/runner.rb

@@ -10,40 +10,81 @@ module EacCli
     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.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
-      extend ClassMethods
+      the_module.alias_runner_class_methods(self, '', 'original')
+
+      extend AfterClassMethods
       include InstanceMethods
       ::EacCli::Docopt::RunnerExtension.check(self)
     end
 
-    module ClassMethods
-      def create(*context_args)
+    module AfterClassMethods
+      def create(*runner_context_args)
         r = new
-        r.context = ::EacCli::Runner::Context.new(*context_args)
+        r.runner_context = ::EacCli::Runner::Context.new(r, *runner_context_args)
+        r
+      end
+
+      def run(*runner_context_args)
+        r = create(*runner_context_args)
+        r.parsed
+        r.run
         r
       end
 
       def runner_definition(&block)
-        @runner_definition ||= ::EacCli::Definition.new
+        @runner_definition ||= super_runner_definition
         @runner_definition.instance_eval(&block) if block
         @runner_definition
       end
+
+      def super_runner_definition
+        superclass.try(:runner_definition).if_present(&:dup) || ::EacCli::Definition.new
+      end
     end
 
     module InstanceMethods
-      def context
-        return @context if @context
+      def runner_context
+        return @runner_context if @runner_context
 
         raise 'Context was required, but was not set yet'
       end
 
-      def context=(new_context)
-        @context = new_context
+      def runner_context=(new_runner_context)
+        @runner_context = new_runner_context
         @parsed = nil
       end
 
       def parsed
-        @parsed ||= ::EacCli::Parser.new(self.class.runner_definition).parse(context.argv)
+        @parsed ||= ::EacCli::Parser.new(self.class.runner_definition).parse(runner_context.argv)
       end
     end
   end

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

@@ -5,13 +5,30 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   module Runner
     class Context
-      attr_reader :argv, :parent, :program_name
+      attr_reader :argv, :parent, :program_name, :runner
 
-      def initialize(*context_args)
+      def initialize(runner, *context_args)
         options = context_args.extract_options!
-        @argv = (context_args[0] || options.delete(:argv)).freeze
+        @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)
+        return runner.send(method_name, *args) if runner.respond_to?(method_name)
+        return parent_call(method_name, *args) if parent.present?
+
+        raise ::NameError, "No method \"#{method_name}\" found in #{runner} or in its ancestors"
+      end
+
+      protected
+
+      def parent_call(method_name, *args)
+        return parent.context(method_name, *args) if parent.respond_to?(:context)
+
+        parent.runner_context.call(method_name, *args)
       end
     end
   end

data/vendor/eac_cli/lib/eac_cli/runner_with.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  module RunnerWith
+    require_sub __FILE__
+  end
+end

data/vendor/eac_cli/lib/eac_cli/runner_with/help.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  module RunnerWith
+    module Help
+      common_concern do
+        include ::EacCli::Runner
+
+        runner_definition.alt do
+          options_arg false
+          bool_opt '-h', '--help', 'Show help.', usage: true
+        end
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/runner_with/output_file.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  module RunnerWith
+    module OutputFile
+      common_concern do
+        include ::EacCli::Runner
+
+        runner_definition do
+          arg_opt '-o', '--output-file', 'Output to file.'
+        end
+      end
+
+      def run_output
+        if parsed.output_file.present?
+          ::File.write(parsed.output_file, output_content)
+        else
+          out output_content
+        end
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/runner_with/subcommands.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  module RunnerWith
+    module Subcommands
+      common_concern do
+        include ::EacCli::Runner
+      end
+
+      EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME = :extra_available_subcommands
+
+      def available_subcommands
+        @available_subcommands ||= available_subcommands_auto.merge(available_subcommands_extra)
+      end
+
+      def available_subcommands_auto
+        self.class.constants
+            .map { |name| [name.to_s.underscore.gsub('_', '-'), self.class.const_get(name)] }
+            .select { |c| ::EacCli::Runner.runner?(c[1]) }
+            .to_h.with_indifferent_access
+      end
+
+      def available_subcommands_extra
+        if respond_to?(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME, true)
+          send(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME)
+        else
+          {}
+        end
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        return run_with_subcommand(*arguments, &block) if
+        run_with_subcommand_alias_run?(method_name)
+
+        super
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        run_with_subcommand_alias_run?(method_name) || super
+      end
+
+      def run_with_subcommand
+        if subcommand_name
+          subcommand_runner.run
+        else
+          run_without_subcommand
+        end
+      end
+
+      def run_with_subcommand_alias_run?(method_name)
+        subcommands? && method_name.to_sym == :run
+      end
+
+      def run_without_subcommand
+        "Method #{__method__} should be overrided in #{self.class.name}"
+      end
+
+      def subcommands?
+        self.class.runner_definition.subcommands?
+      end
+
+      def subcommand_args
+        parsed.fetch(::EacCli::Definition::SUBCOMMAND_ARGS_ARG)
+      end
+
+      def subcommand_class
+        available_subcommands[subcommand_name].if_present { |v| return v }
+
+        raise(::EacCli::Parser::Error.new(
+                self.class.runner_definition, runner_context.argv,
+                "Subcommand \"#{subcommand_name}\" not found " \
+                  "(Available: #{available_subcommands.keys}"
+              ))
+      end
+
+      def subcommand_name
+        parsed.fetch(::EacCli::Definition::SUBCOMMAND_NAME_ARG)
+      end
+
+      def subcommand_program
+        subcommand_name
+      end
+
+      def subcommand_runner
+        @subcommand_runner ||= subcommand_class.create(
+          argv: subcommand_args,
+          program_name: subcommand_program,
+          parent: self
+        )
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacCli
-  VERSION = '0.5.0'
+  VERSION = '0.11.1'
 end