eac_tools 0.104.0 → 0.105.1

data/sub/eac_cli/spec/lib/eac_cli/parser/alternative/subcommands_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'eac_cli/definition/alternative'
+require 'eac_cli/parser/alternative'
+
+RSpec.describe EacCli::Parser::Alternative, '#subcommands' do
+  let(:instance) { described_class.new(alternative, argv) }
+  let(:actual_parsed) { instance.parsed.to_h.symbolize_keys }
+  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

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'eac_cli/definition/alternative'
+require 'eac_cli/parser/alternative'
+
+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
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner'
+
+RSpec.describe EacCli::Runner, '#for_context' do
+  let(:parent_runner_class) do
+    example = self
+    Class.new do
+      include example.described_class
+
+      def self.name
+        'ParentRunnerClass'
+      end
+
+      for_context :method_for_context
+
+      def run; end
+
+      def method_for_context; end
+
+      def method_not_for_context; end
+    end
+  end
+
+  let(:child_runner_class1) do # rubocop:disable RSpec/IndexedLet
+    example = self
+    Class.new do
+      include example.described_class
+
+      def self.name
+        'ChildRunnerClass1'
+      end
+
+      def run
+        method_for_context
+        runner_context.call(:method_for_context)
+        runner_context.call(:method_not_for_context)
+      end
+    end
+  end
+
+  let(:child_runner_class2) do # rubocop:disable RSpec/IndexedLet
+    example = self
+    Class.new do
+      include example.described_class
+
+      def self.name
+        'ChildRunnerClass2'
+      end
+
+      def run
+        method_not_for_context
+      end
+    end
+  end
+
+  let(:parent_runner) { parent_runner_class.create }
+  let(:context_args) { [{ argv: [], parent: parent_runner }] }
+  let(:child_runner) { child_runner_class.create(*context_args) }
+
+  it { expect(parent_runner.for_context?(:method_for_context)).to be(true) }
+  it { expect(parent_runner.for_context?(:method_not_for_context)).to be(false) }
+
+  context 'when method is for context' do
+    let(:child_runner_class) { child_runner_class1 }
+
+    it do
+      expect { child_runner.run }.not_to raise_error
+    end
+  end
+
+  context 'when method is not for context' do
+    let(:child_runner_class) { child_runner_class2 }
+
+    it do
+      expect { child_runner.run }.to raise_error(NameError)
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner'
+
+RSpec.describe EacCli::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 '-p', '--opt2', 'A boolean option'
+        arg_opt '-q', '--opt4', 'A repeatable argument option.', repeat: true
+        bool_opt '-r', '--opt5', 'A repeatable boolean option', repeat: true
+        arg_opt '-s', '--opt6', 'A argument option with default value', default: 'DEFAULT'
+        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
+  end
+
+  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 --opt6 6] }
+    let(:parsed_expected) do
+      { opt1: 'aaa', opt2: true, opt3: false, opt4: [], opt5: 0, opt6: '6', pos1: 'bbb',
+        pos2: %w[ccc ddd] }
+    end
+
+    it { expect(parsed_actual).to eq(parsed_expected) }
+    it { expect(instance.parsed.opt1).to eq('aaa') }
+    it { expect(instance.parsed.opt2?).to be(true) }
+    it { expect(instance.parsed.pos1).to eq('bbb') }
+    it { expect(instance.parsed.pos2).to eq(%w[ccc ddd]) }
+  end
+
+  context 'with long option and argument in same position' do
+    let(:argv) { %w[--opt1=aaa pos1] }
+
+    it { expect(instance.parsed.opt1).to eq('aaa') }
+  end
+
+  context 'with valid grouped short options' do
+    let(:argv) { %w[-po aaa pos1] }
+
+    it { expect(instance.parsed.opt1).to eq('aaa') }
+    it { expect(instance.parsed.opt2?).to be(true) }
+  end
+
+  context 'with invalid grouped short options' do
+    let(:argv) { %w[-op aaa pos1] }
+
+    it do
+      expect { instance.parsed }.to raise_error(EacCli::Parser::Error)
+    end
+  end
+
+  context 'when only required args are supplied' do
+    let(:argv) { %w[bbb] }
+    let(:parsed_expected) do
+      { opt1: nil, opt2: false, opt3: false, opt4: [], opt5: 0, opt6: 'DEFAULT', pos1: 'bbb',
+        pos2: [] }
+    end
+
+    it { expect(parsed_actual).to eq(parsed_expected) }
+    it { expect(instance.parsed.opt1).to be_nil }
+    it { expect(instance.parsed.opt2?).to be(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(:argv) { %w[] }
+
+    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) do
+      { opt1: nil, opt2: false, opt3: true, opt4: [], opt5: 0, opt6: 'DEFAULT', pos1: nil,
+        pos2: [] }
+    end
+
+    it { expect(parsed_actual).to eq(parsed_expected) }
+    it { expect(instance.parsed.opt3?).to be(true) }
+  end
+
+  context 'when repeated options are supplied' do
+    let(:argv) { %w[--opt5 -rrr --opt4=A -q B --opt4 C AAA] }
+    let(:parsed_expected) do
+      { opt1: nil, opt2: false, opt3: false, opt4: %w[A B C], opt5: 4, opt6: 'DEFAULT', pos1: 'AAA',
+        pos2: [] }
+    end
+
+    it { expect(parsed_actual).to eq(parsed_expected) }
+  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
+          pos_arg :pos1
+        end
+
+        def run; end
+      end
+    end
+
+    let(:argv) { %w[aaa bbb] }
+
+    it do
+      expect { instance.parsed }.to raise_error(EacCli::Parser::Error)
+    end
+  end
+end

data/sub/eac_cli/spec/lib/eac_cli/runner_with/confirmation/input_result_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner_with/confirmation/input_result'
+require 'eac_cli/speaker'
+require 'eac_ruby_utils'
+
+RSpec.describe EacCli::RunnerWith::Confirmation::InputResult do
+  let(:speaker) { EacCli::Speaker.new }
+
+  around do |example|
+    EacRubyUtils::Speaker.context.on(speaker) { example.run }
+  end
+
+  before do
+    allow(speaker).to receive(:warn) { |message| raise(message.to_s) }
+  end
+
+  [
+    ['n', false, false],
+    ['N', false, true],
+    ['y', true, false],
+    ['Y', true, true]
+  ].each do |test_values|
+    user_input, confirm, for_all = test_values
+    context "when user input is \"#{user_input}\"" do
+      let(:instance) { described_class.by_message('A message') }
+
+      before do
+        allow(speaker).to receive(:request_string).and_return(user_input)
+      end
+
+      it { expect(instance.confirm?).to eq(confirm) }
+      it { expect(instance.for_all?).to eq(for_all) }
+    end
+  end
+end

data/sub/eac_cli/spec/lib/eac_cli/runner_with/confirmation_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner_with/confirmation'
+
+RSpec.describe EacCli::RunnerWith::Confirmation do
+  let(:runner) do
+    the_module = described_class
+    Class.new do
+      include the_module
+
+      runner_definition do
+        desc 'A stub runner.'
+      end
+
+      def run
+        if confirm?
+          Kernel.puts 'Accepted'
+        else
+          Kernel.puts 'Denied'
+        end
+      end
+    end
+  end
+
+  let(:instance) { runner.create(argv: runner_argv) }
+
+  context 'without --no option' do
+    let(:runner_argv) { %w[--no] }
+
+    it do
+      expect { instance.run }.to output("Denied\n").to_stdout_from_any_process
+    end
+  end
+
+  context 'without --yes option' do
+    let(:runner_argv) { %w[--yes] }
+
+    it do
+      expect { instance.run }.to output("Accepted\n").to_stdout_from_any_process
+    end
+  end
+end

data/sub/eac_cli/spec/lib/eac_cli/runner_with/help/layout_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner_with/help/layout'
+
+RSpec.describe EacCli::RunnerWith::Help::Layout do
+  describe '#list_section' do
+    {
+      ['Options', ['Option A', 'Option B']] => <<~TEXT
+        Options:
+          Option A
+          Option B
+      TEXT
+    }.each do |source, expected|
+      context "when source is #{source}" do
+        it do
+          expect(described_class.list_section(*source)).to eq(expected)
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/spec/lib/eac_cli/runner_with/help_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner_with/help'
+require 'eac_ruby_utils'
+
+RSpec.describe EacCli::RunnerWith::Help do
+  let(:runner) do
+    the_module = described_class
+    Class.new do
+      include the_module
+
+      runner_definition do
+        desc 'A stub runner.'
+        pos_arg :a_argument
+      end
+
+      def run
+        puts 'Runner run'
+      end
+    end
+  end
+
+  [
+    ['--help'],
+    ['trash-pos-arg-before', '--help', 'trash-pos-arg-after', '--any-option', '-XYZ',
+     'other-trash-arg']
+  ].each do |runner_argv|
+    context "when runner ARGV is #{runner_argv}" do
+      let(:instance) { runner.create(argv: runner_argv) }
+      let(:expected_output_source) do
+        <<~OUTPUT
+          A stub runner.
+
+          Usage:
+            __PROGRAM__ [options] <a_argument>
+            __PROGRAM__ --help
+
+          Options:
+            -h --help    Show help.
+        OUTPUT
+      end
+      let(:expected_output) do
+        expected_output_source.gsub('__PROGRAM__', instance.program_name)
+      end
+
+      it 'show help text' do
+        expect { instance.run_run }.to output(expected_output).to_stdout_from_any_process
+      end
+    end
+  end
+end

data/sub/eac_cli/spec/lib/eac_cli/runner_with/output_list_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner_with/output_list'
+
+RSpec.describe EacCli::RunnerWith::OutputList do
+  let(:runner) do
+    the_module = described_class
+    Class.new do
+      include the_module
+
+      def run
+        run_output
+      end
+
+      def list_columns
+        %w[id name]
+      end
+
+      def list_rows
+        [[1, 'João'], [2, 'Maria']].map { |v| Struct.new(:id, :name).new(*v) }
+      end
+    end
+  end
+
+  let(:instance) { runner.create(argv: runner_argv) }
+
+  {
+    'csv' => <<~OUTPUT,
+      id,name
+      1,João
+      2,Maria
+    OUTPUT
+    'tty' => <<~OUTPUT,
+      ┌──┬─────┐
+      │id│name │
+      │1 │João │
+      ├──┼─────┤
+      │2 │Maria│
+      └──┴─────┘
+    OUTPUT
+    'yaml' => <<~OUTPUT
+      ---
+      - id: '1'
+        name: João
+      - id: '2'
+        name: Maria
+    OUTPUT
+  }.each do |format, expected_output|
+    context "with --format=#{format}" do
+      let(:runner_argv) { ['--format', format] }
+
+      it do
+        expect { instance.run }.to output(expected_output).to_stdout_from_any_process
+      end
+    end
+  end
+end

data/sub/eac_cli/spec/lib/eac_cli/runner_with/output_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner_with/output'
+require 'eac_ruby_utils'
+
+RSpec.describe EacCli::RunnerWith::Output do
+  let(:runner) do
+    the_module = described_class
+    Class.new do
+      include the_module
+
+      attr_accessor :temp_dir
+
+      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
+
+      def default_file_to_output
+        temp_dir.join('default_file')
+      end
+    end
+  end
+
+  let(:stub_text) { 'STUB_TEXT' }
+  let(:instance) do
+    r = runner.create(argv: runner_argv)
+    r.temp_dir = temp_dir
+    r
+  end
+  let(:temp_dir) { EacRubyUtils::Fs::Temp.directory }
+
+  after { temp_dir.remove }
+
+  context 'without --output option' do
+    let(:runner_argv) { [stub_text] }
+
+    it do
+      expect { instance.run }.to output(stub_text).to_stdout_from_any_process
+    end
+  end
+
+  context 'without --output option as to stdout' do
+    let(:runner_argv) { ['--output', EacCli::RunnerWith::Output::STDOUT_OPTION, stub_text] }
+
+    it do
+      expect { instance.run }.to output(stub_text).to_stdout_from_any_process
+    end
+  end
+
+  context 'without --output option as to default file' do
+    let(:output_file) { temp_dir.join('default_file') }
+    let(:runner_argv) do
+      ['--output', EacCli::RunnerWith::Output::DEFAULT_FILE_OPTION,
+       stub_text]
+    end
+
+    before { instance.run }
+
+    it { expect(output_file).to exist }
+    it { expect(output_file.read).to eq(stub_text) }
+  end
+
+  context 'with --output option' do
+    let(:output_file) { temp_dir.join('a output file') }
+    let(:runner_argv) { ['--output', output_file.to_path, stub_text] }
+
+    before { instance.run }
+
+    it { expect(output_file).to exist }
+    it { expect(output_file.read).to eq(stub_text) }
+  end
+end