avm-tools 0.120.2 → 0.121.2

data/sub/eac_ruby_utils/lib/eac_ruby_utils/yaml.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require 'date'
-require 'yaml'
-
-module EacRubyUtils
-  # A safe YAML loader/dumper with common types included.
-  class Yaml
-    class << self
-      DEFAULT_PERMITTED_CLASSES = [::Array, ::Date, ::DateTime, ::FalseClass, ::Hash, ::NilClass,
-                                   ::Numeric, ::String, ::Symbol, ::Time, ::TrueClass].freeze
-
-      def dump(object)
-        ::YAML.dump(sanitize(object))
-      end
-
-      def dump_file(path, object)
-        ::File.write(path.to_s, dump(object))
-      end
-
-      def load(string)
-        ::YAML.safe_load(string, permitted_classes)
-      end
-
-      def load_file(path)
-        load(::File.read(path.to_s))
-      end
-
-      def permitted_classes
-        DEFAULT_PERMITTED_CLASSES
-      end
-
-      def sanitize(object)
-        Sanitizer.new(object).result
-      end
-
-      def yaml?(object)
-        return false unless object.is_a?(::String)
-        return false unless object.start_with?('---')
-
-        load(object)
-        true
-      rescue ::Psych::SyntaxError
-        false
-      end
-
-      class Sanitizer
-        attr_reader :source
-
-        RESULT_TYPES = %w[permitted enumerableable hashable].freeze
-
-        def initialize(source)
-          @source = source
-        end
-
-        def result
-          RESULT_TYPES.each do |type|
-            return send("result_#{type}") if send("result_#{type}?")
-          end
-
-          source.to_s
-        end
-
-        private
-
-        def result_enumerableable?
-          source.respond_to?(:to_a) && !source.is_a?(::Hash)
-        end
-
-        def result_enumerableable
-          source.to_a.map { |child| sanitize_value(child) }
-        end
-
-        def result_hashable?
-          source.respond_to?(:to_h)
-        end
-
-        def result_hashable
-          source.to_h.map { |k, v| [k.to_sym, sanitize_value(v)] }.to_h
-        end
-
-        def result_nil?
-          source.nil?
-        end
-
-        def result_nil
-          nil
-        end
-
-        def result_permitted?
-          (::EacRubyUtils::Yaml.permitted_classes - [::Array, ::Hash])
-            .any? { |klass| source.is_a?(klass) }
-        end
-
-        def result_permitted
-          source
-        end
-
-        def sanitize_value(value)
-          self.class.new(value).result
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  require 'eac_ruby_utils/require_sub'
-  ::EacRubyUtils.require_sub __FILE__
-end

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/abstract_methods'
-
-RSpec.describe(::EacRubyUtils::AbstractMethods) do
-  let(:base_class) do
-    the_module = described_class
-    ::Class.new do
-      include the_module
-
-      abstract_methods :method1, :method2
-    end
-  end
-  let(:base_instance) { base_class.new }
-  let(:sub_class) do
-    ::Class.new(base_class) do
-      def method1
-        'a result'
-      end
-    end
-  end
-  let(:sub_instance) { sub_class.new }
-
-  it { expect { base_instance.method1 }.to raise_error(::NoMethodError) }
-  it { expect { base_instance.method2 }.to raise_error(::NoMethodError) }
-  it { expect(sub_instance.method1).to eq('a result') }
-  it { expect { sub_instance.method2 }.to raise_error(::NoMethodError) }
-end

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/arguments_consumer'
-
-RSpec.describe ::EacRubyUtils::ArgumentsConsumer do
-  let(:instance) { described_class.new(%i[a b c d], d: 'd_value') }
-  let(:args) { ['a_value', 'b_value', e: 'e_value'] }
-  let(:result) { instance.parse(args) }
-
-  it { expect(result).to be_a(::Hash) }
-  it { expect(result.count).to eq(5) }
-  it { expect(result.fetch(:a)).to eq('a_value') }
-  it { expect(result.fetch(:b)).to eq('b_value') }
-  it { expect(result.fetch(:c)).to eq(nil) }
-  it { expect(result.fetch(:d)).to eq('d_value') }
-  it { expect(result.fetch(:e)).to eq('e_value') }
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/bit_array'
-
-RSpec.describe ::EacRubyUtils::BitArray do
-  describe '#to_byte_array' do
-    let(:instance) { described_class.new([0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1]) }
-
-    {
-      false => [0xF0, 0xDC],
-      true => [0x0F, 0x3B]
-    }.each do |big_endian, expected_bytes|
-      context "when big-endian is #{big_endian}" do
-        let(:expected_value) { ::EacRubyUtils::ByteArray.new(expected_bytes) }
-
-        it do
-          expect(instance.to_byte_array(big_endian)).to eq(expected_value)
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/blank_not_blank'
-
-RSpec.describe ::EacRubyUtils::BlankNotBlank do
-  let(:instance) { described_class.instance }
-
-  it do
-    expect { described_class.new }.to raise_error(::NoMethodError)
-  end
-
-  it { expect(instance).to be_present }
-  it { expect(instance).not_to be_blank }
-  it { expect(instance).to be_truthy }
-  it { expect(instance).to eq('') }
-end

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

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/byte'
-
-RSpec.describe ::EacRubyUtils::Byte do
-  describe '#[]' do
-    let(:instance) { described_class.new(0xDC) }
-
-    [0, 0, 1, 1, 1, 0, 1, 1].each_with_index do |bit_value, bit_index|
-      context "when bit index is #{bit_index}" do
-        it { expect(instance[bit_index].value).to eq(bit_value) }
-      end
-    end
-  end
-
-  describe '#bit_set' do
-    let(:instance) { described_class.new(0b11011100) }
-
-    {
-      0 => [0b11011100, 0b11011100, 0b11011000, 0b11010100,
-            0b11001100, 0b11011100, 0b10011100, 0b01011100],
-      1 => [0b11011101, 0b11011110, 0b11011100, 0b11011100,
-            0b11011100, 0b11111100, 0b11011100, 0b11011100]
-    }.each do |bit_value, expected_values|
-      expected_values.each_with_index do |expected_value, bit_index|
-        context "when bit index is #{bit_index} and bit value is #{bit_value}" do
-          it do
-            expect(instance.bit_set(bit_index, bit_value))
-              .to eq(described_class.new(expected_value))
-          end
-        end
-      end
-    end
-  end
-
-  describe '#from_bit_array' do
-    let(:bit_array) { [0, 0, 1, 1, 1, 0, 1, 1] }
-
-    { false => 0b11011100, true => 0b00111011 }.each do |big_endian, expected_integer|
-      context "when big-endian is #{big_endian}" do
-        let(:expected_value) { described_class.new(expected_integer) }
-
-        it do
-          expect(described_class.from_bit_array(bit_array, big_endian)).to eq(expected_value)
-        end
-      end
-    end
-
-    it do
-      expect { described_class.from_bit_array([0, 0, 1, 1, 1, 0, 1]) }
-        .to raise_error(::ArgumentError)
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/common_concern'
-
-RSpec.describe ::EacRubyUtils::CommonConcern do
-  let(:instance) do
-    described_class.new do
-      self.valor = 'changed'
-    end
-  end
-
-  let(:stub_module) do
-    ::Module.new do
-      module ClassMethods # rubocop:disable RSpec/LeakyConstantDeclaration
-        def my_class_method
-          'class'
-        end
-      end
-
-      module InstanceMethods # rubocop:disable RSpec/LeakyConstantDeclaration
-        def my_instance_method
-          'from_module'
-        end
-      end
-    end
-  end
-
-  let(:stub_class) do
-    ::Class.new do
-      class << self
-        attr_accessor :valor
-      end
-
-      def my_instance_method
-        'from_class'
-      end
-    end
-  end
-
-  let(:stub_class_instance) { stub_class.new }
-
-  before do
-    instance.setup(stub_module)
-  end
-
-  context 'when included' do
-    before do
-      stub_class.include stub_module
-    end
-
-    it { expect(stub_class_instance.my_instance_method).to eq('from_class') }
-    it { expect(stub_class_instance.class.my_class_method).to eq('class') }
-    it { expect(stub_class_instance.class.valor).to eq('changed') }
-  end
-
-  context 'when prepended' do
-    before do
-      stub_class.prepend stub_module
-    end
-
-    it { expect(stub_class_instance.my_instance_method).to eq('from_module') }
-    it { expect(stub_class_instance.class.my_class_method).to eq('class') }
-    it { expect(stub_class_instance.class.valor).to eq('changed') }
-  end
-end

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

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/common_constructor'
-
-RSpec.describe ::EacRubyUtils::CommonConstructor do
-  ARG_LIST = %i[a b c d].freeze # rubocop:disable RSpec/LeakyConstantDeclaration
-
-  let(:instance) do
-    described_class.new(*ARG_LIST, default: %w[Vcc Vd]) do
-      @z = 'Vz'
-    end
-  end
-
-  let(:a_class) do
-    ::Class.new do
-      attr_reader :z
-    end
-  end
-
-  let(:a_class_instance) { a_class.new('Va', 'Vb', 'Vc') }
-
-  before do
-    instance.setup_class(a_class)
-  end
-
-  it { expect(a_class_instance.z).to eq('Vz') }
-
-  ARG_LIST.each do |attr|
-    expected_value = "V#{attr}"
-    it "attribute \"#{attr}\" equal to \"#{expected_value}\"" do
-      expect(a_class_instance.send(attr)).to eq(expected_value)
-    end
-
-    [false, true].each do |include_all|
-      it "respond_to?('#{attr}', #{include_all}) == #{include_all}" do
-        expect(a_class_instance.respond_to?("#{attr}=", include_all)).to eq(include_all)
-      end
-    end
-  end
-
-  context 'with super class' do
-    let(:super_class) do
-      ::Class.new do
-        attr_reader :super_a, :super_b
-
-        def initialize(a, b) # rubocop:disable Naming/MethodParameterName
-          @super_a = a
-          @super_b = b
-        end
-      end
-    end
-
-    let(:sub_class) do
-      sub_constructor.setup_class(::Class.new(super_class))
-    end
-
-    let(:sub_object) { sub_class.new(1, 2, 3, 4) }
-
-    context 'with super_args parameter' do
-      let(:sub_constructor) do
-        described_class.new(:c, :a, :b, :d, super_args: -> { [c, a] })
-      end
-
-      it { expect(sub_object.a).to eq(2) }
-      it { expect(sub_object.b).to eq(3) }
-      it { expect(sub_object.c).to eq(1) }
-      it { expect(sub_object.d).to eq(4) }
-      it { expect(sub_object.super_a).to eq(1) }
-      it { expect(sub_object.super_b).to eq(2) }
-    end
-
-    context 'without super_args parameter' do
-      let(:sub_constructor) do
-        described_class.new(:c, :a, :b, :d)
-      end
-
-      it { expect(sub_object.a).to eq(2) }
-      it { expect(sub_object.b).to eq(3) }
-      it { expect(sub_object.c).to eq(1) }
-      it { expect(sub_object.d).to eq(4) }
-      it { expect(sub_object.super_a).to eq(2) }
-      it { expect(sub_object.super_b).to eq(3) }
-    end
-
-    context 'with undefined super arguments' do
-      let(:sub_constructor) do
-        described_class.new(:x, :y, :w, :a)
-      end
-
-      it do
-        expect { sub_object }.to raise_error(::ArgumentError)
-      end
-    end
-  end
-
-  context 'with class hierarchy mixed with and without common_constructor' do
-    let(:klass_0) do
-      described_class.new(:a_param).setup_class(::Class.new)
-    end
-
-    let(:klass_1) do
-      ::Class.new(klass_0) do
-        def initialize(a_param)
-          super(a_param)
-        end
-      end
-    end
-
-    let(:klass_2) do
-      ::Class.new(klass_1)
-    end
-
-    let(:klass_3) do
-      described_class.new(:a_param).setup_class(::Class.new(klass_2))
-    end
-
-    4.times.each do |i|
-      context "wit #{i}-th class" do
-        let(:class_instance) { send("klass_#{i}").new(:a) }
-
-        it { expect(class_instance.a_param).to eq(:a) }
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/compact'
-
-::RSpec.describe ::EacRubyUtils::Compact do
-  let(:object) { ::OpenStruct.new(a_attr: 'a_value', b_attr: 'b_value') }
-  let(:instance) { described_class.new(object, %w[a_attr b_attr]) }
-
-  describe '#to_a' do
-    it do
-      expect(instance.to_a).to eq(%w[a_value b_value])
-    end
-  end
-
-  describe '#to_h' do
-    it do
-      expect(instance.to_h).to eq(a_attr: 'a_value', b_attr: 'b_value')
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/compare_by'
-
-RSpec.describe ::EacRubyUtils::CompareBy do
-  let(:instance) { described_class.new(%i[field1 field2]) }
-  let(:klass) do
-    ::Class.new do
-      attr_reader :field1, :field2
-      def initialize(field1, field2)
-        @field1 = field1
-        @field2 = field2
-      end
-    end
-  end
-  let(:o1) { klass.new(1, 2) }
-  let(:o2) { klass.new(2, 1) }
-  let(:o3) { klass.new(1, 1) }
-
-  before { instance.apply(klass) }
-
-  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/custom_format_spec.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/custom_format'
-
-class StubObjectData
-  def x_value
-    'X1'
-  end
-
-  def y_value
-    'Y1'
-  end
-end
-
-RSpec.describe ::EacRubyUtils::CustomFormat do
-  let(:instance) { described_class.new(x: :x_value, y: :y_value, z: :unexistent) }
-  let(:ok_format) { instance.format('|%%|%y|%x|%y|') } # rubocop:disable Style/FormatStringToken
-  let(:ok_string_expected) { '|%|Y1|X1|Y1|' }
-  let(:fail_format) { instance.format('|%z|') }
-
-  it do
-    expect(ok_format.sequences).to include(:x, :y)
-  end
-
-  it do
-    expect(fail_format.sequences).to include(:z)
-  end
-
-  context 'when object source is a hash' do
-    let(:object_source) { { x_value: 'X1', y_value: 'Y1' } }
-
-    context 'when hash has all keys' do
-      it do
-        expect(ok_format.with(object_source)).to eq(ok_string_expected)
-      end
-    end
-
-    context 'when hash has not all keys' do
-      it do
-        expect(fail_format.with(object_source)).to eq('||')
-      end
-    end
-  end
-
-  context 'when object source is not a hash' do
-    let(:object_source) { ::StubObjectData.new }
-
-    context 'when object has all methods' do
-      it do
-        expect(ok_format.with(object_source)).to eq(ok_string_expected)
-      end
-    end
-
-    context 'when object has not all methods' do
-      it do
-        expect { fail_format.with(object_source) }.to raise_error(::ArgumentError)
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/enum'
-
-::RSpec.describe ::EacRubyUtils::Enum do
-  let(:klass) do
-    ::Class.new(described_class) do
-      attr_reader :color
-      def initialize(key, color = :none)
-        super(key)
-        @color = color
-      end
-
-      enum :horse
-      enum :pig, [:pink]
-      enum(:dog, :white)
-      enum(:cat) { :black }
-    end
-  end
-
-  it { expect(klass.horse).to be_a(klass) }
-  it { expect(klass.pig).to be_a(klass) }
-  it { expect(klass.dog).to be_a(klass) }
-  it { expect(klass.cat).to be_a(klass) }
-
-  it { expect(klass.horse.color).to eq(:none) }
-  it { expect(klass.pig.color).to eq(:pink) }
-  it { expect(klass.dog.color).to eq(:white) }
-  it { expect(klass.cat.color).to eq(:black) }
-
-  it { expect(klass.const_get(:HORSE)).to eq(klass.horse) }
-  it { expect(klass.const_get(:PIG)).to eq(klass.pig) }
-  it { expect(klass.const_get(:DOG)).to eq(klass.dog) }
-  it { expect(klass.const_get(:CAT)).to eq(klass.cat) }
-
-  it { expect(klass.values).to eq([klass.horse, klass::PIG, klass.dog, klass::CAT]) }
-
-  describe '#enum' do
-    it do
-      expect { klass.enum(:PiG) }.to raise_error(::ArgumentError)
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/envs/executable_spec.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/envs/executable'
-require 'eac_ruby_utils/envs/local_env'
-
-RSpec.describe ::EacRubyUtils::Envs::Executable do
-  let(:env) { ::EacRubyUtils::Envs::LocalEnv.new }
-
-  context 'when program exist' do
-    let(:instance) { described_class.new(env, 'cat', '--version') }
-
-    it { expect(instance.exist?).to eq(true) }
-    it { expect { instance.validate! }.not_to raise_error }
-    it { expect(instance.validate).to be_blank }
-    it { expect(instance.command).to be_a(::EacRubyUtils::Envs::Command) }
-  end
-
-  context 'when program does not exist' do
-    let(:instance) { described_class.new(env, 'this_cannot_exist', '--version') }
-
-    it { expect(instance.exist?).to eq(false) }
-
-    it {
-      expect { instance.validate! }.to raise_error(
-        described_class.const_get('ProgramNotFoundError')
-      )
-    }
-
-    it { expect(instance.validate).to be_present }
-
-    it {
-      expect { instance.command }.to raise_error(
-        described_class.const_get('ProgramNotFoundError')
-      )
-    }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/envs/ssh_env_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/envs/ssh_env'
-
-RSpec.describe ::EacRubyUtils::Envs::SshEnv do
-  describe '#ssh_command_line' do
-    {
-      'eduardo@localhost' => 'ssh eduardo@localhost',
-      'ssh://eduardo@localhost' => 'ssh eduardo@localhost',
-      'ssh://eduardo@localhost:2222' => 'ssh -p 2222 eduardo@localhost',
-      'localhost' => 'ssh localhost'
-    }.each do |input, expected|
-      it "convert \"#{input}\" to \"#{expected}\"" do
-        env = described_class.new(input)
-        expect(env.send('ssh_command_line')).to eq(expected)
-      end
-    end
-
-    ['my user@hostname', 'http://hostname', 'ssh:/invalid-test', 'Fulano de tal'].each do |input|
-      it "\"#{input}\" raise error" do
-        expect { described_class.new(input) }.to raise_error(StandardError)
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/fs/extname_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/fs/extname'
-
-RSpec.describe ::EacRubyUtils::Fs do
-  describe '#extname' do
-    {
-      'After.Life.S01E01.WEBRip.x264-ION10.mp4' => '.mp4',
-      's01e01.en.srt' => '.en.srt',
-      's01e01.srt' => '.srt',
-      '/path/to/file.tar.gz' => '.tar.gz'
-    }.each do |source, expected|
-      context "when source is \"#{source}\"" do
-        it { expect(described_class.extname(source)).to eq(expected) }
-      end
-    end
-  end
-end