avm-tools 0.76.1 → 0.77.0

data/vendor/eac_cli/lib/eac_cli/parser/alternative/argv.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module Argv
+        def argv_enum
+          @argv_enum ||= argv.each
+        end
+
+        def argv_pending?
+          argv_enum.ongoing?
+        end
+      end
+    end
+  end
+end

data/vendor/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/vendor/eac_cli/lib/eac_cli/parser/alternative/options.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module Options
+        DOUBLE_DASH = '--'
+
+        private
+
+        attr_accessor :argument_option, :double_dash
+
+        def argument_option_collect_argv(option)
+          self.argument_option = option
+          self.phase = PHASE_OPTION_ARGUMENT
+        end
+
+        def argv_current_option?
+          phase == PHASE_ANY && argv_enum.peek.start_with?('-')
+        end
+
+        def argv_current_double_dash?
+          argv_enum.peek == DOUBLE_DASH && !double_dash
+        end
+
+        def boolean_option_collect_argv(option)
+          collector.collect(option, true)
+        end
+
+        def option_argument_collect_argv_value
+          collector.collect(argument_option, argv_enum.peek)
+          self.argument_option = nil
+          self.phase = PHASE_ANY
+        end
+
+        def option_collect_argv_value
+          return double_dash_collect_argv_value if argv_current_double_dash?
+
+          alternative.options.any? do |option|
+            next false unless [option.short, option.long].include?(argv_enum.peek)
+
+            if option.argument?
+              argument_option_collect_argv(option)
+            else
+              boolean_option_collect_argv(option)
+            end
+
+            true
+          end || raise_argv_current_invalid_option
+        end
+
+        def raise_argv_current_invalid_option
+          raise_error "Invalid option: \"#{argv_enum.peek}\""
+        end
+      end
+    end
+  end
+end

data/vendor/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/vendor/eac_cli/lib/eac_cli/runner.rb

@@ -28,7 +28,7 @@ module EacCli
         sklass = klass.singleton_class
         return unless sklass.method_defined?(from)
 
-        sklass.alias_method to, from
+        sklass.send(:alias_method, to, from)
       end
 
       def build_method_name(name, suffix)
@@ -84,7 +84,7 @@ module EacCli
       end
 
       def parsed
-        @parsed ||= ::EacCli::Parser.new(self.class.runner_definition).parse(runner_context.argv)
+        @parsed ||= ::EacCli::Parser.new(self.class.runner_definition, runner_context.argv).parsed
       end
     end
   end

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

@@ -10,7 +10,7 @@ module EacCli
         include ::EacCli::Runner
 
         runner_definition.alt do
-          options_arg false
+          options_argument false
           bool_opt '-h', '--help', 'Show help.', usage: true
         end
       end

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

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

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'eac_cli/definition/alternative'
+
+RSpec.describe ::EacCli::Definition::Alternative do
+  let(:instance) { described_class.new }
+
+  it { expect { instance.arg_opt '-a', '--opt2', 'A argument option' }.not_to raise_error }
+  it { expect { instance.bool_opt '-b', '--opt1', 'A boolean option' }.not_to raise_error }
+  it { expect { instance.options_argument(true) }.not_to raise_error }
+  it { expect { instance.pos_arg :pos1 }.not_to raise_error }
+  it { expect { instance.pos_arg :pos2, optional: true, repeat: true }.not_to raise_error }
+  it { expect { instance.subcommands }.not_to raise_error }
+end

data/vendor/eac_cli/spec/lib/eac_cli/docopt/runner_extension_spec.rb

@@ -22,4 +22,14 @@ RSpec.describe ::EacCli::Docopt::RunnerExtension do
 
   it { expect(instance.options.fetch('--opt1')).to eq('aaa') }
   it { expect(instance.options.fetch('<pos1>')).to eq('bbb') }
+  it { expect(instance.doc).to eq(<<~EXPECTED) }
+    A stub runner.
+
+    Usage:
+      __PROGRAM__ [options] <pos1>
+
+    Options:
+      -o --opt1=<value>    A argument option
+
+  EXPECTED
 end

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

@@ -23,9 +23,14 @@ RSpec.describe ::EacCli::Runner do
     end
   end
 
+  let(:instance) { runner_class.create(argv) }
+  let(:parsed_actual) { instance.parsed.to_h.symbolize_keys }
+
   context 'when all args are supplied' do
-    let(:instance) { runner_class.create(%w[--opt1 aaa --opt2 bbb ccc ddd]) }
+    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') }
@@ -33,8 +38,10 @@ RSpec.describe ::EacCli::Runner do
   end
 
   context 'when only required args are supplied' do
-    let(:instance) { runner_class.create(%w[bbb]) }
+    let(:argv) { %w[bbb] }
+    let(:parsed_expected) { { opt1: nil, opt2: false, pos1: 'bbb', pos2: [] } }
 
+    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') }
@@ -42,7 +49,7 @@ RSpec.describe ::EacCli::Runner do
   end
 
   context 'when required args are not supplied' do
-    let(:instance) { runner_class.create(%w[]) }
+    let(:argv) { %w[] }
 
     it do
       expect { instance.parsed }.to raise_error(::EacCli::Parser::Error)
@@ -50,8 +57,10 @@ RSpec.describe ::EacCli::Runner do
   end
 
   context 'when alternative args are supplied' do
-    let(:instance) { runner_class.create(%w[--opt3]) }
+    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
 
@@ -69,7 +78,7 @@ RSpec.describe ::EacCli::Runner do
       end
     end
 
-    let(:instance) { runner_class.create(%w[aaa bbb]) }
+    let(:argv) { %w[aaa bbb] }
 
     it do
       expect { instance.parsed }.to raise_error(::EacCli::Parser::Error)

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