ehbrs-tools 0.15.0 → 0.16.4

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

@@ -3,34 +3,92 @@
 require 'eac_ruby_utils/common_constructor'
 
 RSpec.describe ::EacRubyUtils::CommonConstructor do
-  ARG_LIST = %i[a b c d].freeze
+  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
 
-  class MyClass
-    attr_reader :z
+  let(:a_class) do
+    ::Class.new do
+      attr_reader :z
+    end
   end
 
-  let(:subject) { MyClass.new('Va', 'Vb', 'Vc') }
+  let(:a_class_instance) { a_class.new('Va', 'Vb', 'Vc') }
 
   before do
-    instance.setup_class(::MyClass)
+    instance.setup_class(a_class)
   end
 
-  it { expect(subject.z).to eq('Vz') }
+  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(subject.send(attr)).to eq(expected_value)
+      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(subject.respond_to?("#{attr}=", include_all)).to eq(include_all)
+        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

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/configs_spec.rb

@@ -28,4 +28,19 @@ RSpec.describe ::EacRubyUtils::Configs do
 
     it { expect(::YAML.load_file(storage_path)).to eq(parent: { child: 'value1' }) }
   end
+
+  describe '#read' do
+    let(:present_key) { 'a.present.key' }
+    let(:blank_key) { 'a.blank.key' }
+
+    before do
+      instance[present_key] = 'A value'
+      instance[blank_key] = ''
+      instance.save
+      instance.load
+    end
+
+    it { expect(instance[present_key]).to be_present }
+    it { expect(instance[blank_key]).to be_present }
+  end
 end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/enumerator/current_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/enumerator/current'
+
+RSpec.describe ::Enumerator do
+  let(:list) { %w[a b] }
+  let(:instance) { list.each }
+
+  it { expect(instance).to be_a(described_class) }
+  it { expect(instance.current).to eq('a') }
+
+  context 'with first next' do
+    before { instance.next }
+
+    it { expect(instance.current).to eq('b') }
+  end
+
+  context 'with last next' do
+    before do
+      instance.next
+      instance.next
+    end
+
+    it { expect(instance.current).to eq(nil) }
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/enumerator/stopped'
+
+RSpec.describe ::Enumerator 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/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/paths_hash_spec.rb

@@ -3,20 +3,20 @@
 require 'eac_ruby_utils/paths_hash'
 
 RSpec.describe ::EacRubyUtils::PathsHash do
-  describe '#[]' do
-    let(:source_hash) do
-      {
-        parent: {
-          child1: {
-            child1_1: 'v1_1',
-            child1_2: 'v1_2'
-          },
-          child2: 'v2'
-        }
+  let(:source_hash) do
+    {
+      parent: {
+        child1: {
+          child1_1: 'v1_1',
+          child1_2: 'v1_2'
+        },
+        child2: 'v2'
       }
-    end
-    let(:instance) { described_class.new(source_hash) }
+    }
+  end
+  let(:instance) { described_class.new(source_hash) }
 
+  describe '#[]' do
     {
       'parent.child1.child1_1' => 'v1_1',
       'parent.child1.child1_2' => 'v1_2',
@@ -38,7 +38,7 @@ RSpec.describe ::EacRubyUtils::PathsHash do
   end
 
   describe '#[]=' do
-    let(:instance) { described_class.new }
+    let(:source_hash) { {} }
 
     before do
       instance['a.b.c'] = '123'
@@ -46,4 +46,43 @@ RSpec.describe ::EacRubyUtils::PathsHash do
 
     it { expect(instance.to_h).to eq(a: { b: { c: '123' } }) }
   end
+
+  describe '#fetch' do
+    {
+      'parent.child1.child1_1' => 'v1_1',
+      'parent.child1.child1_2' => 'v1_2',
+      'parent.child1.child1_2.no_exist' => ::EacRubyUtils::PathsHash::EntryKeyError,
+      'parent.child1.child1_3' => ::EacRubyUtils::PathsHash::EntryKeyError,
+      'parent.child2' => 'v2',
+      'no_exist' => ::EacRubyUtils::PathsHash::EntryKeyError,
+      'parent.child1' => {
+        child1_1: 'v1_1',
+        child1_2: 'v1_2'
+      }
+    }.each do |entry_key, expected_value|
+      if expected_value.is_a?(::Class) && expected_value < ::Exception
+        it "raise error #{expected_value}" do
+          expect { instance.fetch(entry_key) }.to raise_error(expected_value)
+        end
+      else
+        it "\#fetch return \"#{expected_value}\"" do
+          expect(instance.fetch(entry_key)).to eq(expected_value)
+        end
+      end
+    end
+  end
+
+  describe '#key?' do
+    {
+      'parent.child1.child1_1' => true,
+      'parent.child1.child1_2' => true,
+      'parent.child1.child1_2.no_exist' => false,
+      'parent.child1.child1_3' => false,
+      'parent.child2' => true,
+      'no_exist' => false,
+      'parent.child1' => true
+    }.each do |entry_key, expected_value|
+      it { expect(instance.key?(entry_key)).to eq(expected_value) }
+    end
+  end
 end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/struct_spec.rb

@@ -3,7 +3,8 @@
 require 'eac_ruby_utils/struct'
 
 RSpec.describe ::EacRubyUtils::Struct do
-  let(:instance) { described_class.new(a: 1, b: '') }
+  let(:instance) { described_class.new('a' => 1, b: '') }
+  let(:other) { described_class.new('a' => 'm1', c: 'm2') }
 
   describe '#[]' do
     it { expect(instance[:a]).to eq(1) }
@@ -35,6 +36,12 @@ RSpec.describe ::EacRubyUtils::Struct do
     it { expect { instance.fetch('c?') }.to raise_error(::KeyError) }
   end
 
+  describe '#merge' do
+    let(:merged) { instance.merge(other) }
+
+    it { expect(merged.to_h).to eq(a: 'm1', b: '', c: 'm2') }
+  end
+
   describe '#property_method' do
     it { expect(instance.a).to eq(1) }
     it { expect(instance.a?).to eq(true) }
@@ -43,4 +50,8 @@ RSpec.describe ::EacRubyUtils::Struct do
     it { expect { instance.c }.to raise_error(::NoMethodError) }
     it { expect { instance.c? }.to raise_error(::NoMethodError) }
   end
+
+  describe '#to_h' do
+    it { expect(instance.to_h).to eq(a: 1, b: '') }
+  end
 end

data/vendor/ehbrs_ruby_utils/lib/ehbrs_ruby_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EhbrsRubyUtils
-  VERSION = '0.3.0'
+  VERSION = '0.5.0'
 end

data/vendor/ehbrs_ruby_utils/lib/ehbrs_ruby_utils/videos/container.rb

@@ -1,11 +1,39 @@
 # frozen_string_literal: true
 
 require 'eac_ruby_utils/core_ext'
+require 'ehbrs_ruby_utils/executables'
+require 'ehbrs_ruby_utils/videos/stream'
+require 'json'
 
 module EhbrsRubyUtils
   module Videos
-    module Container
-      require_sub __FILE__
+    class Container
+      enable_simple_cache
+      common_constructor :path do
+        self.path = path.to_pathname
+      end
+
+      ::EhbrsRubyUtils::Videos::Stream.lists.codec_type.each_value do |stream_type|
+        define_method stream_type.to_s.pluralize do
+          streams.select { |stream| stream.codec_type == stream_type }
+        end
+      end
+
+      private
+
+      def probe_data_uncached
+        ::JSON.parse(
+          ::EhbrsRubyUtils::Executables.ffprobe.command(
+            '-hide_banner', '-print_format', 'json', '-show_format', '-show_streams', path
+          ).execute!
+        ).deep_symbolize_keys.freeze
+      end
+
+      def streams_uncached
+        probe_data.fetch(:streams).map do |stream_ffprobe_data|
+          ::EhbrsRubyUtils::Videos::Stream.new(stream_ffprobe_data)
+        end
+      end
     end
   end
 end

data/vendor/ehbrs_ruby_utils/lib/ehbrs_ruby_utils/videos/convert_job.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'ehbrs/executables'
+require 'fileutils'
+
+module EhbrsRubyUtils
+  module Videos
+    class ConvertJob
+      FORMATS_TO_EXTENSIONS = {
+        'matroska' => '.mkv'
+      }.freeze
+
+      enable_console_speaker
+      enable_simple_cache
+      common_constructor :input, :ffmpeg_convert_args do
+        self.input = input.to_pathname.expand_path
+        raise "Input file \"#{input}\" does not exist or is not a file" unless input.file?
+      end
+
+      def run
+        if converted.exist?
+          warn("Converted file already exist: \"#{converted}\"")
+        else
+          convert
+          swap
+        end
+      end
+
+      def target
+        input.dirname.join("#{input.basename('.*')}#{target_extension}")
+      end
+
+      private
+
+      def command_args_uncached
+        r = ['-i', input] + ffmpeg_convert_args
+        r += ['-f', format_by_input] if format_by_args.blank?
+        r + [converting]
+      end
+
+      def convert
+        infov 'Input', input
+        infov 'Target', target
+        infov 'Convert args', command_args.shelljoin
+        ::Ehbrs::Executables.ffmpeg.command.append(command_args).system!
+      end
+
+      def format_by_args_uncached
+        ffmpeg_convert_args.rindex('-f').if_present do |option_index|
+          ffmpeg_convert_args[option_index + 1]
+        end
+      end
+
+      def format_by_input
+        FORMATS_TO_EXTENSIONS.invert[target_extension_by_input].if_present { |v| return v }
+
+        raise 'Unknonwn target format'
+      end
+
+      def format_to_extension(format)
+        FORMATS_TO_EXTENSIONS[format].if_present(".#{format}")
+      end
+
+      def swap
+        ::FileUtils.mv(input, converted)
+        ::FileUtils.mv(converting, target)
+      end
+
+      def converting
+        target.basename_sub { |b| "#{b}.converting" }
+      end
+
+      def converted
+        input.basename_sub { |b| "#{b}.converted" }
+      end
+
+      def target_extension
+        target_extension_by_args || target_extension_by_input
+      end
+
+      def target_extension_by_args
+        format_by_args.if_present { |v| format_to_extension(v) }
+      end
+
+      def target_extension_by_input
+        ::File.extname(input)
+      end
+    end
+  end
+end

data/vendor/ehbrs_ruby_utils/lib/ehbrs_ruby_utils/videos/stream.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EhbrsRubyUtils
+  module Videos
+    class Stream
+      enable_simple_cache
+      enable_listable
+
+      lists.add_symbol :codec_type, :audio, :video, :subtitle, :data
+
+      common_constructor :ffprobe_data do
+        self.ffprobe_data = ffprobe_data.symbolize_keys.freeze
+        self.class.lists.codec_type.value_validate!(codec_type)
+      end
+
+      lists.codec_type.each_value do |v|
+        define_method "#{v}?" do
+          codec_type == v
+        end
+      end
+
+      def to_s
+        "#{index}|#{codec_type}|#{codec_name}|#{language}"
+      end
+
+      def to_h
+        ffprobe_data
+      end
+
+      %i[index codec_name codec_long_name].each do |method_name|
+        define_method method_name do
+          ffprobe_data.fetch(method_name)
+        end
+      end
+
+      def codec_type
+        ffprobe_data.fetch(:codec_type).to_sym
+      end
+
+      def tags
+        ffprobe_data[:tags].if_present({}, &:symbolize_keys)
+      end
+
+      def language
+        tags[:language]
+      end
+    end
+  end
+end