eac_tools 0.117.5 → 0.119.0

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/enumerator/stopped_spec.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Enumerator, '#stopped' do
-  let(:list) { %w[a b] }
-  let(:instance) { list.each }
-
-  it { expect(instance).to be_a(described_class) }
-  it { expect(instance.peek).to eq('a') }
-  it { expect(instance).to be_ongoing }
-  it { expect(instance).not_to be_stopped }
-
-  context 'with first next' do
-    before { instance.next }
-
-    it { expect(instance.peek).to eq('b') }
-    it { expect(instance).to be_ongoing }
-    it { expect(instance).not_to be_stopped }
-  end
-
-  context 'with last next' do
-    before do
-      instance.next
-      instance.next
-    end
-
-    it { expect { instance.peek }.to raise_error(StopIteration) }
-    it { expect(instance).not_to be_ongoing }
-    it { expect(instance).to be_stopped }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/hash/if_key_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Hash, '#if_key' do
-  subject(:instance) { { a: 'a_value' } }
-
-  it do
-    expect(instance.if_key(:a)).to eq('a_value')
-  end
-
-  it do
-    expect(instance.if_key(:a) { |v| "_#{v}_" }).to eq('_a_value_')
-  end
-
-  it do
-    expect(instance.if_key(:b)).to be_nil
-  end
-
-  it do
-    expect(instance.if_key(:b, 'default_value')).to eq('default_value')
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/hash/options_consumer_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Hash, '#options_consumer' do
-  let(:a_hash) { { a: 'a_value', b: 'b_value', c: 'c_value' } }
-  let(:instance) { a_hash.to_options_consumer }
-
-  it 'returns a OptionsConsumer' do
-    expect(instance).to be_a(EacRubyUtils::OptionsConsumer)
-  end
-
-  it do
-    expect(instance.left_data).to eq({ a: 'a_value', b: 'b_value', c: 'c_value' }
-      .with_indifferent_access)
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/hash/sym_keys_hash_spec.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Hash, '#sym_keys_hash' do
-  let(:a_hash) { { 'a' => 'a_value', 1 => '1_value', s: 's_value' } }
-
-  describe '#to_sym_keys_hash' do
-    it 'converts all keys to symbols' do
-      expect(a_hash.to_sym_keys_hash).to eq(a: 'a_value', '1': '1_value', s: 's_value')
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/integer/rjust_zero_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Integer, '#rjust_zero' do
-  [
-    [0, 1, '0'],
-    [9999, 2, '9999'],
-    [5, 2, '05'],
-    [123, 6, '000123']
-  ].each do |sample|
-    instance, size, expected_value = sample # rubocop:disable RSpec/LeakyLocalVariable
-
-    context "when instance is #{instance} and size is #{size}" do
-      it do
-        expect(instance.rjust_zero(size)).to eq(expected_value)
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/module/compare_by_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Module, '#compare_by' do
-  let(:klass) do
-    Class.new do
-      compare_by :field1, :field2
-      attr_reader :field1, :field2
-
-      def initialize(field1, field2)
-        @field1 = field1
-        @field2 = field2
-      end
-    end
-  end
-  let(:o1) { klass.new(1, 2) } # rubocop:disable RSpec/IndexedLet
-  let(:o2) { klass.new(2, 1) } # rubocop:disable RSpec/IndexedLet
-  let(:o3) { klass.new(1, 1) } # rubocop:disable RSpec/IndexedLet
-
-  describe '#comparable' do
-    it { expect(o1).to be < o2 }
-    it { expect(o1).to be > o3 }
-    it { expect(o2).to be > o3 }
-    it { expect([o1, o2, o3].sort).to eq([o3, o1, o2]) }
-  end
-
-  describe '#equality' do
-    it { expect(o1).not_to eq(o2) }
-    it { expect(o1).not_to eq(o3) }
-    it { expect(o2).not_to eq(o3) }
-
-    it { expect(o1).to eq(klass.new(1, 2)) }
-    it { expect(o2).to eq(klass.new(2, 1)) }
-    it { expect(o3).to eq(klass.new(1, 1)) }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/module/listable_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Module, '#listable' do
-  let(:stub_class) do
-    Class.new do
-      enable_listable
-    end
-  end
-
-  describe '#enable_listable' do
-    it { expect(stub_class.included_modules).to include(EacRubyUtils::Listable) }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/module/simple_cache_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Module, '#simple_cache' do
-  let(:stub_class) do
-    Class.new do
-      enable_simple_cache
-    end
-  end
-
-  describe '#enable_simple_cache' do
-    it { expect(stub_class.included_modules).to include(EacRubyUtils::SimpleCache) }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/module/speaker_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Module, '#speaker' do
-  let(:stub_class) do
-    Class.new do
-      enable_speaker
-    end
-  end
-
-  describe '#enable_speaker' do
-    it { expect(stub_class.included_modules).to include(EacRubyUtils::Speaker::Sender) }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/object/call_if_proc_spec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Object, '#call_if_proc' do
-  describe '#call_if_proc' do
-    it { expect(nil.call_if_proc).to be_nil }
-    it { expect('a string'.call_if_proc).to eq('a string') }
-    it { expect(-> { 'a returned value' }.call_if_proc).to eq('a returned value') }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/object/compact_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Object, '#compact' do
-  let(:instance) { Struct.new(:a_attr, :b_attr).new('a_value', 'b_value') }
-  let(:attributes) { %w[a_attr b_attr] }
-
-  describe '#compact_to_a' do
-    it do
-      expect(instance.compact_to_a(*attributes)).to eq(%w[a_value b_value])
-    end
-  end
-
-  describe '#compact_to_h' do
-    it do
-      expect(instance.compact_to_h(*attributes)).to eq(a_attr: 'a_value', b_attr: 'b_value')
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/object/if_present_spec.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Object, '#if_present' do
-  describe '#if_present' do
-    it { expect(nil.if_present).to be_nil }
-    it { expect(nil.if_present('default')).to eq('default') }
-    it { expect(nil.if_present('default') { |_v| 'calculated' }).to eq('default') }
-    it { expect('present'.if_present('default')).to eq('present') }
-    it { expect('present'.if_present { |v| "#{v}_calculated" }).to eq('present_calculated') }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/object/recursive_build_spec.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Object, '#recursive_build' do
-  let(:item_class) do
-    Class.new do
-      class << self
-        def create(label, dependencies_keys)
-          item = new(label, dependencies_keys)
-          registry[item.label] = item
-          item
-        end
-
-        def registry
-          @registry ||= {}
-        end
-      end
-
-      attr_reader :label, :dependencies_keys
-
-      def initialize(label, dependencies_keys)
-        @label = label
-        @dependencies_keys = dependencies_keys.freeze
-      end
-
-      def dependencies
-        dependencies_keys.map { |key| self.class.registry.fetch(key) }
-      end
-
-      def to_s
-        label
-      end
-    end
-  end
-
-  items = [
-    [:a, %w[c], %w[a c]],
-    [:b, %w[a], %w[b a c]],
-    [:c, [], %w[c]],
-    [:d, %w[a b c e], %w[d a b c e]],
-    [:e, %w[c b], %w[e c b a]]
-  ]
-
-  items.each do |item|
-    let(item[0]) { item_class.create(item[0].to_s, item[1]) }
-    before { send(item[0]) }
-  end
-
-  describe '#result' do
-    items.each do |item|
-      context "when root is \"#{item[0]}\"" do
-        let(:root) { send(item[0]) }
-        let(:dependencies) { item[2].map { |d| send(d) } }
-
-        it "is #{item[2]}" do
-          expect(root.recursive_build(&:dependencies)).to eq(dependencies)
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/pathname/assert_parent_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Pathname, '#assert_parent' do
-  let(:root) { temp_dir }
-  let(:parent_dir) { root.join('parent_dir') }
-  let(:instance) { parent_dir.join('the_file') }
-  let(:result) { instance.assert_parent }
-
-  it { expect(parent_dir).not_to exist }
-  it { expect(instance).not_to exist }
-
-  context 'when parent is asserted' do
-    before { result }
-
-    it { expect(parent_dir).to exist }
-    it { expect(instance).not_to exist }
-    it { expect(result).to eq(instance) }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/pathname/basename_noext_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Pathname, '#basename_noext' do
-  describe '#basename_noext' do
-    {
-      'After.Life.S01E01.WEBRip.x264-ION10.mp4' =>
-        %w[After.Life.S01E01.WEBRip.x264-ION10 After.Life.S01E01.WEBRip.x264-ION10.mp4
-           After.Life.S01E01.WEBRip.x264-ION10 After.Life.S01E01.WEBRip.x264-ION10],
-      's01e01.en.srt' => %w[s01e01 s01e01.en.srt s01e01.en s01e01 s01e01],
-      's01e01.srt' => %w[s01e01 s01e01.srt s01e01 s01e01 s01e01],
-      '/path/to/file.tar.gz' => %w[file file.tar.gz file.tar file file]
-    }.each do |source, expected_values|
-      expected_values.each_with_index do |expected_value, index|
-        limit = index - 1 # rubocop:disable RSpec/LeakyLocalVariable
-        context "when source is \"#{source}\" and limit is \"#{limit}\"" do
-          let(:instance) { described_class.new(source) }
-          let(:expected_path) { described_class.new(expected_value) }
-
-          it { expect(instance.basename_noext(limit)).to eq(expected_path) }
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/pathname/basename_sub_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Pathname, '#basename_sub' do
-  it do
-    expect(described_class.new('/absolute/path/to/file').basename_sub { |_b| 'other_file' }).to eq(
-      described_class.new('/absolute/path/to/other_file')
-    )
-  end
-
-  it do
-    expect(described_class.new('file').basename_sub { |b| "#{b}_appended" }).to eq(
-      described_class.new('file_appended')
-    )
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/pathname/child_of_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Pathname, '#child_of' do
-  describe 'child_of?' do
-    [
-      ['/foo/bar/baz', '/foo/bar', true],
-      ['/foo/../foo/bar/../bar/baz', '/foo/bar', true],
-      ['/foo/bar/baz', '/foo/../foo/bar/../bar', true],
-      ['/foo/bar/baz', '/boink', false],
-      ['/foo/bar/../not_bar/baz', '/foo/bar', false],
-      ['/foo/bar/../bar_not/baz', '/foo/bar', false],
-      ['/foo', '/foo/bar', false],
-      ['/foo', '/bar', false],
-      ['/foo', '/foo', false]
-    ].each do |test_values|
-      child_path, parent_path, expected_value = test_values # rubocop:disable RSpec/LeakyLocalVariable
-      context "when child=\"#{child_path}\" and parent=\"#{parent_path}\"" do
-        it do
-          expect(Pathname(child_path).child_of?(Pathname(parent_path))).to be(expected_value)
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/pathname/parent_n_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Pathname, '#parent_n' do
-  [
-    ['/absolute/path/to/file', 0, '/absolute/path/to/file'],
-    ['/absolute/path/to/file', 1, '/absolute/path/to'],
-    ['/absolute/path/to/file', 2, '/absolute/path'],
-    ['/absolute/path/to/file', 3, '/absolute'],
-    ['/absolute/path/to/file', 4, '/'],
-    ['/absolute/path/to/file', 5, '/'],
-    ['relative/path/to/file', 0, 'relative/path/to/file'],
-    ['relative/path/to/file', 1, 'relative/path/to'],
-    ['relative/path/to/file', 2, 'relative/path'],
-    ['relative/path/to/file', 3, 'relative'],
-    ['relative/path/to/file', 4, '.'],
-    ['relative/path/to/file', 5, '..'],
-    ['relative/path/to/file', 6, '../..']
-  ].each do |test_data|
-    input_path = test_data[0] # rubocop:disable RSpec/LeakyLocalVariable
-    context "when path is \"#{input_path}\"" do
-      let(:n) { test_data[1] }
-      let(:expected_path) { test_data[2] }
-
-      it do
-        expect(described_class.new(input_path).parent_n(n)).to(
-          eq(described_class.new(expected_path))
-        )
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/string/delimited_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe String, '#delimeted' do # rubocop:disable RSpec/SpecFilePathFormat
-  let(:instance) { 'A text with <b>content between</b> tags.' }
-
-  {
-    ['<b>', '</b>'] => {
-      'inner' => 'content between',
-      'without_inner' => 'A text with <b></b> tags.',
-      'outer' => '<b>content between</b>',
-      'without_outer' => 'A text with  tags.'
-    },
-    ['<b>', '</br>'] => {
-      'inner' => '',
-      'without_inner' => 'A text with <b>content between</b> tags.',
-      'outer' => '',
-      'without_outer' => 'A text with <b>content between</b> tags.'
-    }
-  }.each do |delimiters, expected_values|
-    context "when delimiters are #{delimiters}" do
-      let(:bdel) { delimiters[0] }
-      let(:edel) { delimiters[1] }
-
-      expected_values.each do |method_suffix, expected_value|
-        method_name = "delimited_#{method_suffix}" # rubocop:disable RSpec/LeakyLocalVariable
-        it "#{method_name} should return \"#{expected_value}\"" do
-          expect(instance.send(method_name, bdel, edel)).to eq(expected_value)
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/recursive_builder_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe EacRubyUtils::RecursiveBuilder do
-  let(:item_class) do
-    Class.new do
-      class << self
-        def create(label, dependencies_keys)
-          item = new(label, dependencies_keys)
-          registry[item.label] = item
-          item
-        end
-
-        def registry
-          @registry ||= {}
-        end
-      end
-
-      attr_reader :label, :dependencies_keys
-
-      def initialize(label, dependencies_keys)
-        @label = label
-        @dependencies_keys = dependencies_keys.freeze
-      end
-
-      def dependencies
-        dependencies_keys.map { |key| self.class.registry.fetch(key) }
-      end
-
-      def to_s
-        label
-      end
-    end
-  end
-
-  items = [
-    [:a, %w[c], %w[a c]],
-    [:b, %w[a], %w[b a c]],
-    [:c, [], %w[c]],
-    [:d, %w[a b c e], %w[d a b c e]],
-    [:e, %w[c b], %w[e c b a]]
-  ]
-
-  items.each do |item|
-    let(item[0]) { item_class.create(item[0].to_s, item[1]) }
-    before { send(item[0]) }
-  end
-
-  describe '#result' do
-    items.each do |item|
-      context "when root is \"#{item[0]}\"" do
-        let(:root) { send(item[0]) }
-        let(:dependencies) { item[2].map { |d| send(d) } }
-        let(:builder) do
-          described_class.new(root, &:dependencies)
-        end
-
-        it "is #{item[2]}" do
-          expect(builder.result).to eq(dependencies)
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/require_sub/base_spec/stubbed_module_a.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-class RequireSubStubClass
-  module StubbedModuleA
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/require_sub/base_spec/stubbed_not_module.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-class RequireSubStubClass
-  class StubbedNotModule # rubocop:disable Lint/EmptyClass
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/require_sub/base_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-class RequireSubStubClass # rubocop:disable Lint/EmptyClass
-end
-
-RSpec.describe EacRubyUtils::RequireSub::Base do
-  let(:instance) { described_class.new(__FILE__, base: RequireSubStubClass, include_modules: true) }
-
-  before do
-    instance.apply
-  end
-
-  it do
-    expect(RequireSubStubClass.included_modules)
-      .to include(RequireSubStubClass::StubbedModuleA)
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/rspec/setup/setup_manager_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe(EacRubyUtils::Rspec::Setup::SetupManager) do
-  describe '#setup_manager' do
-    it do
-      expect(setup_manager).to be_a(EacRubyUtils::Rspec::SetupManager)
-    end
-  end
-
-  describe '#app_root_path' do
-    it { expect(app_root_path).to be_a(Pathname) }
-    it { expect(app_root_path).to be_directory }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/ruby/on_clean_environment_spec.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe EacRubyUtils::Ruby, '#on_clean_environment' do
-  let(:envvar_name) { 'BUNDLE_NOT_EXISTENT_ENV_VAR' }
-  let(:envvar_value) { 'any value' }
-  let(:noruby_envvar_name) { 'ANY_ENVIRONMENT_VARIABLE' }
-  let(:noruby_envvar_value) { 'another any value' }
-
-  before do
-    ENV[envvar_name] = envvar_value
-    ENV[noruby_envvar_name] = noruby_envvar_value
-  end
-
-  it do # rubocop:disable RSpec/MultipleExpectations
-    expect(ENV.fetch(envvar_name, nil)).to eq(envvar_value)
-    described_class.on_clean_environment do
-      expect(ENV.fetch(envvar_name, nil)).to be_nil
-    end
-    expect(ENV.fetch(envvar_name, nil)).to eq(envvar_value)
-  end
-
-  it do # rubocop:disable RSpec/MultipleExpectations
-    expect(ENV.fetch(noruby_envvar_name, nil)).to eq(noruby_envvar_value)
-    described_class.on_clean_environment do
-      expect(ENV.fetch(noruby_envvar_name, nil)).to eq(noruby_envvar_value)
-    end
-    expect(ENV.fetch(noruby_envvar_name, nil)).to eq(noruby_envvar_value)
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/ruby/on_replace_objects_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe EacRubyUtils::Ruby, '#on_replace_objects' do
-  let(:stub_class) do
-    Class.new do
-      def self.my_class_method
-        'Original'
-      end
-
-      def my_instance_method
-        'Original'
-      end
-    end
-  end
-
-  let(:stub_instance) { stub_class.new }
-
-  let(:replace_block) do
-    proc { 'Replaced' }
-  end
-
-  describe '#my_instance_method' do
-    let(:before) { stub_instance.my_instance_method }
-    let(:inside) do
-      described_class.on_replace_objects do |replacer|
-        replacer.replace_instance_method(stub_class, :my_instance_method, &replace_block)
-        stub_instance.my_instance_method
-      end
-    end
-    let(:after) { stub_instance.my_instance_method }
-
-    before do
-      before
-      inside
-      after
-    end
-
-    it { expect(before).to eq('Original') }
-    it { expect(inside).to eq('Replaced') }
-    it { expect(after).to eq('Original') }
-  end
-
-  describe '#replace_self_method' do
-    let(:before) { stub_class.my_class_method }
-    let(:inside) do
-      described_class.on_replace_objects do |replacer|
-        replacer.replace_self_method(stub_class, :my_class_method, &replace_block)
-        stub_class.my_class_method
-      end
-    end
-    let(:after) { stub_class.my_class_method }
-
-    before do
-      before
-      inside
-      after
-    end
-
-    it { expect(before).to eq('Original') }
-    it { expect(inside).to eq('Replaced') }
-    it { expect(after).to eq('Original') }
-  end
-end