avm-tools 0.68.0 → 0.70.0

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Parser
+    class Error < ::StandardError
+      def initialize(definition, argv, message)
+        @definition = definition
+        @argv = argv
+        super(message)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'optparse'
+
+module EacCli
+  class Parser
+    class OptionsCollection
+      SEP = ' '
+      IDENT = SEP * 2
+      OPTION_DESC_SEP = IDENT * 2
+
+      enable_simple_cache
+      common_constructor(:definition, :argv, :collector) { collect }
+      attr_reader :arguments
+
+      private
+
+      def collect
+        build_banner
+        build_options
+        @arguments = option_parser.parse(argv)
+      end
+
+      def option_parser_uncached
+        ::OptionParser.new
+      end
+
+      def build_banner
+        option_parser.banner = "#{definition.description}\n\n#{section('usage')}"
+      end
+
+      def build_options
+        definition.options.each do |option|
+          build_option(option)
+        end
+      end
+
+      def build_option(option)
+        option_parser.on(
+          *[option_short(option), option_long(option), option.description].reject(&:blank?)
+        ) do |value|
+          collector.collect(option, value)
+        end
+      end
+
+      def positional_argument(positional)
+        if positional.subcommand?
+          ::EacRubyUtils::Console::DocoptRunner::SUBCOMMANDS_MACRO
+        else
+          r = "<#{positional.name}>"
+          r += '...' if positional.repeat?
+          r = "[#{r}]" if positional.optional?
+          r
+        end
+      end
+
+      def option_argument(option)
+        option_long(option)
+      end
+
+      def option_long(option)
+        b = option.long
+        b += '=VALUE' if option.argument?
+        b
+      end
+
+      def option_short(option)
+        b = option.short
+        b += 'VALUE' if option.argument?
+        b
+      end
+
+      def section(header, include_header = true)
+        b = include_header ? "#{header.humanize}:\n" : ''
+        b += send("self_#{header}") + "\n"
+        # TO-DO: implement alternatives
+        b
+      end
+
+      def self_options
+        definition.options.map { |option| IDENT + option_definition(option) }.join("\n")
+      end
+
+      def self_usage
+        IDENT + self_usage_arguments.join(SEP)
+      end
+
+      def self_usage_arguments
+        [::EacRubyUtils::Console::DocoptRunner::PROGRAM_MACRO] +
+          definition.options_argument.if_present([]) { |_v| ['[options]'] } +
+          self_usage_arguments_options +
+          self_usage_arguments_positional
+      end
+
+      def self_usage_arguments_options
+        definition.options.select(&:show_on_usage?).map { |option| option_argument(option) }
+      end
+
+      def self_usage_arguments_positional
+        definition.positional.map { |p| positional_argument(p) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Parser
+    class ParseResult
+      common_constructor :definition, :argv
+
+      def result
+        ::EacCli::Parser::Collector.to_data(definition) do |collector|
+          ::EacCli::Parser::PositionalCollection.new(
+            definition,
+            ::EacCli::Parser::OptionsCollection.new(definition, argv, collector).arguments,
+            collector
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_cli/parser/error'
+
+module EacCli
+  class Parser
+    class PositionalCollection
+      common_constructor(:definition, :argv, :collector) { collect }
+
+      private
+
+      def collected
+        @collected ||= ::Set.new
+      end
+
+      def collect
+        argv.each { |argv_value| colect_argv_value(argv_value) }
+        return unless pending_required_positional?
+
+        raise ::EacCli::Parser::Error.new(
+          definition, argv, 'No value for required positional ' \
+            "\"#{current_positional.identifier}\""
+        )
+      end
+
+      def colect_argv_value(argv_value)
+        collector.collect(current_positional, argv_value)
+        collected << current_positional
+        positional_enumerator.next unless current_positional.repeat?
+      end
+
+      def pending_required_positional?
+        !(current_positional.blank? || current_positional.optional? ||
+            collected.include?(current_positional))
+      end
+
+      def positional_enumerator
+        @positional_enumerator ||= definition.positional.each
+      end
+
+      def current_positional
+        positional_enumerator.peek
+      rescue ::StopIteration
+        nil
+      end
+    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,24 @@
+# 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)
+    include ::EacCli::Runner
+    enable_simple_cache
+    enable_console_speaker
+    runners.each do |runner|
+      include runner_with_to_module(runner)
+    end
+  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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'eac_cli/definition'
+require 'eac_cli/docopt/runner_extension'
+require 'eac_cli/parser'
+require 'eac_ruby_utils/core_ext'
+
+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
+
+      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
+      the_module.alias_runner_class_methods(self, '', 'original')
+
+      extend AfterClassMethods
+      include InstanceMethods
+      ::EacCli::Docopt::RunnerExtension.check(self)
+    end
+
+    module AfterClassMethods
+      def create(*runner_context_args)
+        r = new
+        r.runner_context = ::EacCli::Runner::Context.new(*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 ||= 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 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).parse(runner_context.argv)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  module Runner
+    class Context
+      attr_reader :argv, :parent, :program_name
+
+      def initialize(*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)
+      end
+    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/version.rb

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

data/vendor/eac_cli/spec/lib/eac_cli/runner_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/console/docopt_runner'
+require 'eac_cli/runner'
+
+RSpec.describe ::EacCli::Runner do
+  let(:stub_runner) do
+    r = Class.new(::EacRubyUtils::Console::DocoptRunner) do
+      def run; end
+    end
+    r.include described_class
+    r.runner_definition do
+      desc 'A stub runner.'
+      arg_opt '-o', '--opt1', 'A argument option'
+      pos_arg 'pos1'
+    end
+    r
+  end
+
+  let(:instance) { stub_runner.new(argv: %w[-o aaa bbb]) }
+
+  before { instance.run }
+
+  it { expect(instance.options.fetch('--opt1')).to eq('aaa') }
+  it { expect(instance.options.fetch('<pos1>')).to eq('bbb') }
+
+  context 'without docopt runner' do
+    let(:runner_class) do
+      the_module = described_class
+      ::Class.new do
+        include the_module
+
+        runner_definition do
+          arg_opt '-o', '--opt1', 'A arg option.'
+          bool_opt '-o', '--opt2', 'A boolean option'
+          pos_arg :pos1
+          pos_arg :pos2, repeat: true, optional: true
+        end
+
+        def run; end
+      end
+    end
+
+    context 'when all args are supplied' do
+      let(:instance) { runner_class.create(%w[--opt1 aaa --opt2 bbb ccc ddd]) }
+
+      it { expect(instance.parsed.opt1).to eq('aaa') }
+      it { expect(instance.parsed.opt2?).to eq(true) }
+      it { expect(instance.parsed.pos1).to eq('bbb') }
+      it { expect(instance.parsed.pos2).to eq(%w[ccc ddd]) }
+    end
+
+    context 'when only required args are supplied' do
+      let(:instance) { runner_class.create(%w[bbb]) }
+
+      it { expect(instance.parsed.opt1).to be_nil }
+      it { expect(instance.parsed.opt2?).to eq(false) }
+      it { expect(instance.parsed.pos1).to eq('bbb') }
+      it { expect(instance.parsed.pos2).to eq([]) }
+    end
+
+    context 'when required args are not supplied' do
+      let(:instance) { runner_class.create(%w[]) }
+
+      it do
+        expect { instance.parsed }.to raise_error(::EacCli::Parser::Error)
+      end
+    end
+  end
+end