RubyGems - ehbrs-tools - Versions diffs - 0.19.0 → 0.23.0 - Mend

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-require 'eac_ruby_utils/console/docopt_runner'
-RSpec.describe ::EacRubyUtils::Console::DocoptRunner do
-  context 'runner without DOC constant' do
-    class RunnerWithoutDocConstant < ::EacRubyUtils::Console::DocoptRunner
-      def run
-        # Do nothing
-      end
-    end
-    let(:options) { { argv: [] } }
-    it 'raises exception if doc argument is not supplied' do
-      expect { RunnerWithoutDocConstant.new(options) }.to raise_error(::StandardError)
-    end
-    context 'doc argument is supplied' do
-      let(:doc) do
-        <<~DOCUMENT
-          Runner without doc constant.
-          Usage:
-            __PROGRAM__
-        DOCUMENT
-      end
-      let(:options_with_doc) { options.merge(doc: doc) }
-      it 'reads doc from arguments' do
-        expect { RunnerWithoutDocConstant.new(options_with_doc) }.not_to raise_error
-      end
-    end
-  end
-  context 'doc with subcommands' do
-    class RunnerWithSubcommands < ::EacRubyUtils::Console::DocoptRunner
-      attr_accessor :subarg_value, :suboption_value
-      DOC = <<~DOCUMENT
-        A root runner with subcommands.
-        Usage:
-          __PROGRAM__ <parent-arg> __SUBCOMMANDS__
-      DOCUMENT
-      def parent_arg
-        options.fetch('<parent-arg>')
-      end
-      class MySubCommand < ::EacRubyUtils::Console::DocoptRunner
-        DOC = <<~DOCUMENT
-          A root runner with subcommands.
-          Usage:
-            __PROGRAM__ [--suboption=<suboption-value] <subarg-value>
-        DOCUMENT
-        def run
-          parent.suboption_value = options.fetch('--suboption')
-          parent.subarg_value = options.fetch('<subarg-value>')
-        end
-      end
-    end
-    let(:instance) { RunnerWithSubcommands.new }
-    describe '#subcommands?' do
-      it 'returns true' do
-        expect(instance.subcommands?).to eq(true)
-      end
-    end
-    context 'when subcommand is valid' do
-      let(:instance) do
-        RunnerWithSubcommands.new(argv: %w[value0 my-sub-command value1 --suboption value2])
-      end
-      describe '#subcommand_arg_as_list?' do
-        it { expect(instance.subcommand_arg_as_list?).to eq(false) }
-      end
-      describe '#target_doc' do
-        it { expect(instance.target_doc).to include('Subcommands:') }
-      end
-      describe '#subcommand' do
-        it 'is of subcommand class' do
-          expect(instance.subcommand).to be_a(RunnerWithSubcommands::MySubCommand)
-        end
-      end
-      describe '#context' do
-        it 'accesses instance methods by subcommand' do
-          expect(instance.subcommand.context(:parent_arg)).to eq('value0')
-        end
-      end
-      describe '#run' do
-        it 'calls subcommand' do
-          instance.run
-          expect(instance.subarg_value).to eq('value1')
-          expect(instance.suboption_value).to eq('value2')
-        end
-      end
-    end
-    context 'when subcommand is invalid' do
-      let(:instance) { RunnerWithSubcommands.new(argv: %w[value0 invalid-subcommand]) }
-      describe '#run' do
-        it 'raises Docopt::Exit' do
-          expect { instance.run }.to raise_error(::Docopt::Exit)
-        end
-      end
-    end
-    context 'when subcommand as arg list is enabled' do
-      let(:argv) { %w[value0 my-sub-command value1 --suboption value2] }
-      let(:instance) { RunnerWithSubcommands.new(argv: argv, subcommand_arg_as_list: true) }
-      describe '#subcommand_arg_as_list?' do
-        it { expect(instance.subcommand_arg_as_list?).to eq(true) }
-      end
-      describe '#target_doc' do
-        it { expect(instance.target_doc).to include('(my-sub-command)') }
-      end
-      describe '#subcommand_name' do
-        it { expect(instance.subcommand_name).to eq('my-sub-command') }
-      end
-    end
-  end
-end

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-require 'eac_ruby_utils/patches/module/console_speaker'
-RSpec.describe ::Module do
-  class StubClass
-    enable_console_speaker
-  end
-  describe '#enable_console_speaker' do
-    it { expect(StubClass.included_modules).to include(::EacRubyUtils::Console::Speaker) }
-  end
-end

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-require 'eac_ruby_utils/patches/object/template'
-RSpec.describe ::Object do
-  class MyStubWithTemplate
-  end
-  let(:instance) { ::MyStubWithTemplate.new }
-  let(:templates_path) { ::File.join(__dir__, 'template_spec_files', 'path') }
-  before do
-    ::EacRubyUtils::Templates::Searcher.default.included_paths.add(templates_path)
-  end
-  after do
-    ::EacRubyUtils::Templates::Searcher.default.included_paths.delete(templates_path)
-  end
-  describe '#template' do
-    it { expect(instance.template).to be_a(::EacRubyUtils::Templates::File) }
-  end
-end

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-require 'eac_ruby_utils/configs'
-require 'eac_ruby_utils/templates/file'
-RSpec.describe ::EacRubyUtils::Templates::File do
-  let(:files_dir) { ::File.join(__dir__, 'file_spec_files') }
-  let(:source_path) { ::File.join(files_dir, 'source.template') }
-  let(:instance) { described_class.new(source_path) }
-  let(:expected_content) { ::File.read(::File.join(files_dir, 'expected_content')) }
-  describe '#apply' do
-    context 'when config is a hash' do
-      let(:config) { { name: 'Fulano de Tal', age: 33 } }
-      it { expect(instance.apply(config)).to eq(expected_content) }
-    end
-    context 'when config responds to read_entry' do
-      let(:config) { ::EacRubyUtils::Configs.new('rspec_describe_eac_ruby_utils_templates_file') }
-      before do
-        config.clear
-        config['name'] = 'Fulano de Tal'
-        config['age'] = '33'
-      end
-      it { expect(instance.apply(config)).to eq(expected_content) }
-    end
-  end
-  describe '#variables' do
-    it { expect(instance.variables).to eq(::Set.new(%w[name age])) }
-  end
-end

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-require 'eac_ruby_utils/templates/searcher'
-RSpec.describe ::EacRubyUtils::Templates::Searcher do
-  let(:files_dir) { ::File.join(__dir__, 'searcher_spec_files') }
-  let(:instance) do
-    r = described_class.new
-    r.included_paths << ::File.join(files_dir, 'path1')
-    r.included_paths << ::File.join(files_dir, 'path2')
-    r
-  end
-  describe '#template' do
-    {
-      ::EacRubyUtils::Templates::Directory => %w[subdir1],
-      ::EacRubyUtils::Templates::File => %w[subdir1/file1.template subdir1/file2
-                                            subdir1/file3.template],
-      ::NilClass => %w[does_not_exist]
-    }.each do |klass, subpaths|
-      subpaths.each do |subpath|
-        context "when subpath is \"#{subpath}\"" do
-          it "returns a #{klass}'s instance" do
-            expect(instance.template(subpath, false)).to be_a(klass)
-          end
-        end
-      end
-    end
-  end
-end

	@@ -1,2 +0,0 @@
1	- Name: Fulano de Tal
2	- Age: 33

	@@ -1,2 +0,0 @@
1	- Name: %%NAME%%
2	- Age: %%AGE%%

ehbrs-tools 0.19.0 → 0.23.0