avm-tools 0.75.0 → 0.78.0

data/vendor/eac_cli/spec/lib/eac_cli/parser/alternative_spec.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'eac_cli/docopt/runner_extension'
+
+RSpec.describe ::EacCli::Parser::Alternative do
+  let(:instance) { described_class.new(alternative, argv) }
+  let(:actual_parsed) { instance.parsed.to_h.symbolize_keys }
+
+  context 'without subcommands' do
+    let(:alternative) do
+      r = ::EacCli::Definition::Alternative.new
+      r.bool_opt '-b', '--opt1', 'A boolean option'
+      r.arg_opt '-a', '--opt2', 'A argument option'
+      r.bool_opt '-c', '--opt3', 'A required boolean option', required: true
+      r.pos_arg :pos1
+      r.pos_arg :pos2, optional: true, repeat: true
+      r
+    end
+
+    context 'with all values' do
+      let(:argv) { %w[--opt1 --opt2 OPT2 --opt3 POS1 POS2_1 POS2_2] }
+      let(:parsed_expected) do
+        {
+          opt1: true, opt2: 'OPT2', opt3: true, pos1: 'POS1', pos2: %w[POS2_1 POS2_2]
+        }
+      end
+
+      it { expect(instance.error).to be_blank }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'with only required values' do
+      let(:argv) { %w[--opt3 POS1] }
+      let(:parsed_expected) { { opt1: false, opt2: nil, opt3: true, pos1: 'POS1', pos2: [] } }
+
+      it { expect(instance.error).to be_blank }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'with double dash' do
+      let(:argv) { %w[--opt3 POS1 -- --opt1 --] }
+      let(:parsed_expected) do
+        { opt1: false, opt2: nil, opt3: true, pos1: 'POS1', pos2: %w[--opt1 --] }
+      end
+
+      it { expect(instance.error).to be_blank }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'without required positional' do
+      let(:argv) { %w[--opt1 --opt3] }
+      let(:parsed_expected) { { opt1: true, opt2: nil, opt3: true, pos1: nil, pos2: [] } }
+
+      it { expect(instance.error).to be_present }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'without required option' do
+      let(:argv) { %w[--opt1 POS1] }
+      let(:parsed_expected) { { opt1: true, opt2: nil, opt3: false, pos1: 'POS1', pos2: [] } }
+
+      it { expect(instance.error).to be_present }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'without any required option or positional' do
+      let(:argv) { %w[] }
+      let(:parsed_expected) { { opt1: false, opt2: nil, opt3: false, pos1: nil, pos2: [] } }
+
+      it { expect(instance.error).to be_present }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'with excedent positional' do
+      let(:alternative) do
+        r = ::EacCli::Definition::Alternative.new
+        r.pos_arg :pos1
+        r
+      end
+
+      let(:argv) { %w[POS1 POS2] }
+      let(:parsed_expected) { { pos1: 'POS1' } }
+
+      it { expect(instance.error).to be_present }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+  end
+
+  context 'with subcommands' do
+    let(:alternative) do
+      r = ::EacCli::Definition::Alternative.new
+      r.bool_opt '-b', '--opt1', 'A boolean option'
+      r.arg_opt '-a', '--opt2', 'A argument option'
+      r.subcommands
+      r
+    end
+
+    context 'with all values' do
+      let(:argv) { %w[--opt1 --opt2 OPT2 CMD CMD_ARG_1 --CMD_ARG_2] }
+      let(:parsed_expected) do
+        {
+          opt1: true, opt2: 'OPT2',
+          ::EacCli::Definition::Alternative::SUBCOMMAND_NAME_ARG => 'CMD',
+          ::EacCli::Definition::Alternative::SUBCOMMAND_ARGS_ARG => %w[CMD_ARG_1 --CMD_ARG_2]
+        }
+      end
+
+      it { expect(instance.error).to be_blank }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'with only required values' do
+      let(:argv) { %w[CMD] }
+      let(:parsed_expected) do
+        {
+          opt1: false, opt2: nil,
+          ::EacCli::Definition::Alternative::SUBCOMMAND_NAME_ARG => 'CMD',
+          ::EacCli::Definition::Alternative::SUBCOMMAND_ARGS_ARG => []
+        }
+      end
+
+      it { expect(instance.error).to be_blank }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'without required values' do
+      let(:argv) { %w[--opt1] }
+      let(:parsed_expected) do
+        {
+          opt1: true, opt2: nil,
+          ::EacCli::Definition::Alternative::SUBCOMMAND_NAME_ARG => nil,
+          ::EacCli::Definition::Alternative::SUBCOMMAND_ARGS_ARG => []
+        }
+      end
+
+      it { expect(instance.error).to be_present }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+  end
+end

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

@@ -4,67 +4,84 @@ 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
+  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
+        alt do
+          bool_opt '-a', '--opt3', 'A boolean option in a alternative.', required: true
+        end
+      end
+
       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]) }
+  let(:instance) { runner_class.create(argv) }
+  let(:parsed_actual) { instance.parsed.to_h.symbolize_keys }
+
+  context 'when all args are supplied' do
+    let(:argv) { %w[--opt1 aaa --opt2 bbb ccc ddd] }
+    let(:parsed_expected) { { opt1: 'aaa', opt2: true, pos1: 'bbb', pos2: %w[ccc ddd] } }
+
+    it { expect(parsed_actual).to eq(parsed_expected) }
+    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(:argv) { %w[bbb] }
+    let(:parsed_expected) { { opt1: nil, opt2: false, pos1: 'bbb', pos2: [] } }
 
-  before { instance.run }
+    it { expect(parsed_actual).to eq(parsed_expected) }
+    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
 
-  it { expect(instance.options.fetch('--opt1')).to eq('aaa') }
-  it { expect(instance.options.fetch('<pos1>')).to eq('bbb') }
+  context 'when required args are not supplied' do
+    let(:argv) { %w[] }
 
-  context 'without docopt runner' do
+    it do
+      expect { instance.parsed }.to raise_error(::EacCli::Parser::Error)
+    end
+  end
+
+  context 'when alternative args are supplied' do
+    let(:argv) { %w[--opt3] }
+    let(:parsed_expected) { { opt3: true } }
+
+    it { expect(parsed_actual).to eq(parsed_expected) }
+    it { expect(instance.parsed.opt3?).to eq(true) }
+  end
+
+  context 'when extra args are not supplied' 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
+    let(:argv) { %w[aaa bbb] }
 
-    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
+    it do
+      expect { instance.parsed }.to raise_error(::EacCli::Parser::Error)
     end
   end
 end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner_with/output_file'
+require 'eac_ruby_utils/fs/temp'
+
+RSpec.describe ::EacCli::RunnerWith::OutputFile do
+  let(:runner) do
+    the_module = described_class
+    Class.new do
+      include the_module
+
+      runner_definition do
+        desc 'A stub root runner.'
+        pos_arg :input_text
+      end
+
+      def run
+        run_output
+      end
+
+      def output_content
+        parsed.input_text
+      end
+    end
+  end
+
+  let(:stub_text) { 'STUB_TEXT' }
+  let(:instance) { runner.create(argv: runner_argv) }
+
+  context 'without --output-file option' do
+    let(:runner_argv) { [stub_text] }
+
+    it do
+      expect { instance.run }.to output(stub_text).to_stdout_from_any_process
+    end
+  end
+
+  context 'with --output-file option' do
+    let(:output_file) { ::EacRubyUtils::Fs::Temp.file }
+    let(:runner_argv) { ['--output-file', output_file.to_path, stub_text] }
+
+    before do
+      instance.run
+    end
+
+    after do
+      output_file.remove
+    end
+
+    it { expect(output_file).to exist }
+    it { expect(output_file.read).to eq(stub_text) }
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner'
+require 'eac_cli/runner_with/subcommands'
+
+RSpec.describe ::EacCli::RunnerWith::Subcommands do
+  let(:parent_runner) do
+    the_module = described_class
+    the_child = child_runner
+    Class.new do
+      include ::EacCli::Runner
+      include the_module
+      const_set('ChildCmd', the_child)
+
+      runner_definition do
+        desc 'A stub root runner.'
+        arg_opt '-r', '--root-var', 'A root variable.'
+        subcommands
+      end
+
+      delegate :root_var, to: :parsed
+    end
+  end
+
+  let(:child_runner) do
+    ::Class.new do
+      include ::EacCli::Runner
+
+      runner_definition do
+        bool_opt '-c', '--child-opt', 'A boolean option.'
+        pos_arg :child_var
+      end
+
+      def run; end
+    end
+  end
+
+  let(:instance) { parent_runner.create(argv: parent_argv) }
+
+  context 'when subcommand is supplied' do
+    let(:parent_argv) { %w[--root-var 123 child-cmd --child-opt 456] }
+
+    it { expect(instance.parsed.root_var).to eq('123') }
+    it { expect(instance.parsed.subcommand).to eq('child-cmd') }
+    it { expect(instance.parsed.subcommand_args).to eq(%w[--child-opt 456]) }
+    it { expect(instance.subcommand_runner.parsed.child_opt).to eq(true) }
+    it { expect(instance.subcommand_runner.parsed.child_var).to eq('456') }
+  end
+
+  context 'when subcommand is not supplied' do
+    let(:instance) { parent_runner.create(%w[456]) }
+
+    it do
+      expect { instance.run }.to raise_error(::EacCli::Parser::Error)
+    end
+  end
+end

data/vendor/eac_ruby_base0/lib/eac_ruby_base0/application.rb

@@ -1,12 +1,17 @@
 # frozen_string_literal: true
 
 require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/filesystem_cache'
 
 module EacRubyBase0
   class Application
     enable_simple_cache
-    common_constructor :gemspec_dir do
+    enable_listable
+    lists.add_symbol :option, :name, :home_dir
+
+    common_constructor :gemspec_dir, :options, default: [{}] do
       self.gemspec_dir = gemspec_dir.to_pathname
+      self.options = options.symbolize_keys.assert_valid_keys(self.class.lists.option.values).freeze
     end
 
     delegate :version, to: :self_gem
@@ -15,6 +20,32 @@ module EacRubyBase0
       vendor_gems + [self_gem]
     end
 
+    { cache: '.cache', config: '.config', data: '.local/share' }.each do |item, subpath|
+      xdg_env_method_name = "#{item}_xdg_env"
+
+      define_method xdg_env_method_name do
+        ENV["XDG_#{item.upcase}_HOME"].if_present(&:to_pathname)
+      end
+
+      define_method "#{item}_dir" do
+        (send(xdg_env_method_name) || home_dir.join(subpath)).join(name)
+      end
+    end
+
+    def fs_cache
+      @fs_cache ||= ::EacRubyUtils::FilesystemCache.new(
+        cache_dir.join(::EacRubyUtils::FilesystemCache.name.parameterize)
+      )
+    end
+
+    def home_dir
+      @home_dir ||= (options[OPTION_HOME_DIR] || ENV.fetch('HOME')).to_pathname
+    end
+
+    def name
+      options[OPTION_NAME] || self_gem.name
+    end
+
     def vendor_dir
       gemspec_dir.join('vendor')
     end

data/vendor/eac_ruby_base0/lib/eac_ruby_base0/runner.rb

@@ -13,7 +13,7 @@ module EacRubyBase0
         bool_opt '-I', '--no-input', 'Fail if a input is requested.'
         subcommands
         alt do
-          bool_opt '-V', '--version', 'Show version.'
+          bool_opt '-V', '--version', 'Show version.', usage: true, required: true
         end
       end
     end

data/vendor/eac_ruby_base0/lib/eac_ruby_base0/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacRubyBase0
-  VERSION = '0.2.0'
+  VERSION = '0.3.1'
 end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/abstract_methods.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/common_concern'
+
+module EacRubyUtils
+  # Support to abstract methods.
+  #
+  # Usage:
+  #
+  #   require 'eac_ruby_utils/abstract_methods'
+  #
+  #   class BaseClass
+  #     include EacRubyUtils::AbstractMethods
+  #
+  #     abstract_methods :mymethod
+  #   end
+  #
+  #   BaseClass.new.mymethod # raise "Abstract method: mymethod"
+  #
+  #   class SubClass
+  #     def mymethod
+  #       "Implemented"
+  #     end
+  #   end
+  #
+  #   SubClass.new.mymethod # return "Implemented"
+  module AbstractMethods
+    common_concern
+
+    module ClassMethods
+      def abstract_methods(*methods_names)
+        methods_names.each do |method_name|
+          define_method method_name do
+            raise_abstract_method(method_name)
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+      def respond_to_missing?(method_name, include_private = false)
+        super || abstract_method?(method_name)
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        raise_abstract_method(method_name) if abstract_method?(method_name)
+
+        super
+      end
+
+      def abstract_method?(method_name)
+        self.class.abstract_methods.include?(method_name.to_sym)
+      end
+
+      def raise_abstract_method(method_name)
+        raise ::NoMethodError, "Abstract method \"#{method_name}\" hit in \"#{self}\""
+      end
+    end
+  end
+end