ehbrs_ruby_utils 0.40.0 → 0.41.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86fcf26dbec53e9e7e2b04d2197849a7f17ad0850b07d4420e26a115841c3a32
-  data.tar.gz: 3a62e456a9d8965f914b47ccd483a92656058cc0a59f99aef595c772fdfeb05e
+  metadata.gz: 586c5869279d721b48b5cf6d6ce585edc26601a00aff87f412fa0cad3142206e
+  data.tar.gz: bf287e776722f8b92f3f7fe7832fdc574251c4ebee744c1f3018ef2957e278d7
 SHA512:
-  metadata.gz: 171835d362844886ba8032527dd298a8da9913b9a699570686252a35209c8976e77e658ef9ca22a2e386313386a68a1dfc064298832bc9e4a8c622be6a06f89a
-  data.tar.gz: 1b03d32256cbf9e3e27dafd52acaac5ae977a0911d014da72ef97b9ef3ba3ff10e66b62208b139d60a42efc0626b320ba226c6b24dfd1cdbab3310b0eeb3cce6
+  metadata.gz: ba4bc8bce782d16640c2e984ffd02f1a4a8dd390921f136321697efc1d3dd03339baeac2722ff5f1d9f858e44f3d616b3bb1b83dca6358d5993f621c3fd6593a
+  data.tar.gz: f9711900cb11defad1165a869e77bdc5ff160b7a070f79870bd927c624871271476505900b1d45dd88bf7598191809879b84fc9c3f40d5f6a37d5302caf47c83

data/lib/ehbrs_ruby_utils/bga/parsers/game_in_progress.rb

@@ -7,30 +7,40 @@ module EhbrsRubyUtils
   module Bga
     module Parsers
       class GameInProgress < ::Aranha::Parsers::Html::ItemList
-        ITEMS_XPATH = '//*[@id = "gametables_inprogress_all"]' \
-                      '//*[starts-with(@id, "gametableblock_")]'
+        DEFAULT_STATUS = 'asyncplay'
+        ID_PARSER = /table=(\d+)/.to_parser { |m| m[1].to_i }
+        ITEMS_XPATH = '//*[@id = "section-play"]//a[contains(@href, "table=")]'
         STATUS_CLASS_PATTERN = /\Agametable_status_(.+)\z/.freeze
         STATUS_CLASS_PARSER = STATUS_CLASS_PATTERN.to_parser { |m| m[1] }
+        TABLE_COUNT_XPATH =
+          '//*[@id = "section-play"]/h1/span[contains(@class, "font-normal")]/span/text()'
 
-        field :id, :integer, './@id'
-        field :status, :string, './@class'
+        field :href, :string, './@href'
+
+        def data
+          {
+            table_count: table_count,
+            tables: items_data
+          }
+        end
 
         def item_data(idd)
-          %i[status].each do |key|
-            idd[key] = send("process_#{key}", idd.fetch(key))
-          end
-          idd
+          { id: parse_id(idd.fetch(:href)), status: 'asyncplay' }
         end
 
         def items_xpath
           ITEMS_XPATH
         end
 
-        private
+        # @param href [String]
+        # @return [Integer]
+        def parse_id(href)
+          ID_PARSER.parse!(href)
+        end
 
-        def process_status(status)
-          status.split.lazy.map { |s| STATUS_CLASS_PARSER.parse(s.strip) }.find(&:present?) ||
-            raise("No status class found in \"#{status}\"")
+        # @return [Integer]
+        def table_count
+          nokogiri.at_xpath(TABLE_COUNT_XPATH).if_present(-1) { |v| v.text.to_i }
         end
       end
     end

data/lib/ehbrs_ruby_utils/bga/session/player_tables_on_game_in_progress.rb

@@ -13,6 +13,8 @@ module EhbrsRubyUtils
         enable_simple_cache
         common_constructor :session, :player_id
 
+        WAIT_FOR_RESULT_SECONDS = 60
+
         def result
           navigate_to_page
           result_data
@@ -25,14 +27,28 @@ module EhbrsRubyUtils
 
         private
 
+        def current_data
+          ::EhbrsRubyUtils::Bga::Parsers::GameInProgress.from_content(session.current_source).data
+        end
+
         # @return [Array<Hash>]
         def result_data
-          ::EhbrsRubyUtils::Bga::Parsers::GameInProgress.from_content(session.current_source).data
+          cr = nil
+          session.wait(WAIT_FOR_RESULT_SECONDS).until do
+            scroll_down
+            cr = current_data
+            cr.fetch(:tables).count == cr.fetch(:table_count)
+          end
+          cr.fetch(:tables)
         end
 
         def navigate_to_page
           session.navigate.to url
         end
+
+        def scroll_down
+          session.execute_script('window.scrollBy(0, 90)')
+        end
       end
     end
   end

data/lib/ehbrs_ruby_utils/bga/session/skip_trophies.rb

@@ -19,8 +19,8 @@ module EhbrsRubyUtils
           e
         end
 
-        def on_skip_trophies(&block)
-          error = on_rescue_timeout(&block)
+        def on_skip_trophies(...)
+          error = on_rescue_timeout(...)
           return unless error
           raise error unless skip_trophy_overlay?
 

data/lib/ehbrs_ruby_utils/music/lyrics_book/song.rb

@@ -51,7 +51,7 @@ module EhbrsRubyUtils
         private
 
         def container_uncached
-          ::EhbrsRubyUtils::Videos::Container.new(path)
+          ::EhbrsRubyUtils::Videos::File.new(path)
         end
 
         def fetch_lyrics

data/lib/ehbrs_ruby_utils/version.rb

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

data/lib/ehbrs_ruby_utils/videos/{container.rb → file.rb}

@@ -10,7 +10,7 @@ require 'ultimate_lyrics/song_metadata'
 
 module EhbrsRubyUtils
   module Videos
-    class Container
+    class File
       class << self
         def from_file(path)
           new(path)

data/lib/ehbrs_ruby_utils/videos/stream.rb

@@ -10,6 +10,10 @@ module EhbrsRubyUtils
 
       lists.add_symbol :codec_type, :audio, :video, :subtitle, :data, :attachment
 
+      DURATION_TAG_TO_SECONDS_PARSER = /\A(\d{2}):(\d{2}):(\d{2}.\d+)\z/.to_parser do |m|
+        (m[1].to_i * 3600) + (m[2].to_i * 60) + m[3].to_f
+      end
+
       common_constructor :ffprobe_data do
         self.ffprobe_data = ffprobe_data.symbolize_keys.freeze
         self.class.lists.codec_type.value_validate!(codec_type)
@@ -21,8 +25,19 @@ module EhbrsRubyUtils
         end
       end
 
+      # @return [Integer]
+      def codec_tag
+        ffprobe_data.fetch(:codec_tag).to_i(16)
+      end
+
+      # @return [ActiveSupport::Duration, nil]
+      def duration
+        duration_from_root || duration_from_tags
+      end
+
+      # @return [String]
       def to_s
-        "#{index}|#{codec_type}|#{codec_name}|#{language}"
+        [index, codec_type, codec_name, language, codec_tag_string].join('|')
       end
 
       def to_h
@@ -35,7 +50,7 @@ module EhbrsRubyUtils
         end
       end
 
-      %i[codec_name codec_long_name height width].each do |method_name|
+      %i[codec_name codec_long_name codec_tag_string height width].each do |method_name|
         define_method method_name do
           ffprobe_data[method_name]
         end
@@ -60,6 +75,22 @@ module EhbrsRubyUtils
       def title
         tags[:title]
       end
+
+      private
+
+      # @return [ActiveSupport::Duration, nil]
+      def duration_from_root
+        ffprobe_data[:duration].if_present do |v|
+          ::ActiveSupport::Duration.build(v.to_f)
+        end
+      end
+
+      # @return [ActiveSupport::Duration, nil]
+      def duration_from_tags
+        tags[:DURATION].if_present do |v|
+          ::ActiveSupport::Duration.build(DURATION_TAG_TO_SECONDS_PARSER.parse!(v))
+        end
+      end
     end
   end
 end

data/lib/ehbrs_ruby_utils/videos2/convert_job.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'ehbrs_ruby_utils/executables'
+require 'fileutils'
+
+module EhbrsRubyUtils
+  module Videos2
+    class ConvertJob
+      enable_speaker
+      enable_simple_cache
+
+      FORMATS_TO_EXTENSIONS = {
+        'matroska' => '.mkv'
+      }.freeze
+
+      attr_reader :input, :profile
+
+      def initialize(input, profile)
+        raise "Input file \"#{input}\" does not exist" unless ::File.exist?(input.to_s)
+
+        @input = input
+        @profile = profile
+      end
+
+      def run
+        if ::File.exist?(converted)
+          warn("Converted file already exist: \"#{converted}\"")
+        else
+          profile.run_callbacks(:convert) { convert }
+          profile.run_callbacks(:swap) { swap }
+        end
+      end
+
+      def target
+        ::File.join(::File.dirname(input), "#{::File.basename(input, '.*')}#{target_extension}")
+      end
+
+      private
+
+      def command_args_uncached
+        r = ['-i', input] + profile_ffmpeg_args
+        r += ['-f', format_by_input] if format_by_args.blank?
+        r + [converting]
+      end
+
+      def convert
+        infov 'Convert args', command_args.shelljoin
+        ::EhbrsRubyUtils::Executables.ffmpeg.command.append(command_args).system!
+      end
+
+      def format_by_args_uncached
+        profile_ffmpeg_args.rindex('-f').if_present do |option_index|
+          profile_ffmpeg_args[option_index + 1]
+        end
+      end
+
+      def format_by_input
+        r = FORMATS_TO_EXTENSIONS.invert[target_extension_by_input]
+        return if r.present?
+
+        target_extension_by_input.gsub(/\A\./, '')
+      end
+
+      def format_to_extension(format)
+        FORMATS_TO_EXTENSIONS[format].if_present(".#{format}")
+      end
+
+      def profile_ffmpeg_args_uncached
+        profile.ffmpeg_args
+      end
+
+      def swap
+        ::FileUtils.mv(input, converted)
+        ::FileUtils.mv(converting, target)
+      end
+
+      def converting
+        "#{target}.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/lib/ehbrs_ruby_utils/videos2/extract/package.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'ehbrs_ruby_utils/fs/compressed_package'
+require 'ehbrs_ruby_utils/videos2/extract/package_file'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Extract
+      class Package
+        enable_simple_cache
+
+        common_constructor :path, :target_dir, :qualities do
+          self.path = path.to_pathname
+          self.target_dir = target_dir.to_pathname
+        end
+
+        delegate :to_s, to: :path
+
+        def run(delete)
+          selected_files.each(&:copy_to_selected_dir)
+          files.each(&:move_to_quality_dir)
+          extract_dir.rmdir
+          path.unlink if delete
+        end
+
+        private
+
+        def files_uncached
+          ::Pathname.glob("#{extract_dir}/**/*").map do |file|
+            ::EhbrsRubyUtils::Videos2::Extract::PackageFile.new(self, file)
+          end
+        end
+
+        def extract_dir_uncached
+          r = target_dir / path.basename
+          raise "Extract directory \"#{r}\" is a file" if r.file?
+
+          r.rmtree if r.directory?
+          ::EhbrsRubyUtils::Fs::CompressedPackage.new(path).extract_to(r)
+          r
+        end
+
+        def files_qualities_uncached
+          qualities_with_default.select { |q| grouped_files.keys.include?(q) }
+        end
+
+        def grouped_files_uncached
+          r = {}
+          files.each do |file|
+            r[file.quality] ||= []
+            r[file.quality] << file
+          end
+          r
+        end
+
+        def qualities_with_default
+          qualities + [::EhbrsRubyUtils::Videos2::Extract::PackageFile::DEFAULT_QUALITY]
+        end
+
+        def selected_dir_uncached
+          target_dir / 'selected'
+        end
+
+        def selected_files
+          files.select { |f| f.quality == selected_quality }
+        end
+
+        def selected_quality_uncached
+          files_qualities.first
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/extract/package_file.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Extract
+      class PackageFile
+        DEFAULT_QUALITY = '__default__'
+
+        enable_simple_cache
+        common_constructor :package, :path do
+          self.path = path.to_pathname
+        end
+
+        def copy_to_selected_dir
+          ::FileUtils.cp(path.to_path, selected_dir.to_path)
+        end
+
+        def match_quality?(quality)
+          path.basename_sub { |b| b.to_s.downcase }.basename
+            .fnmatch?("*#{quality.downcase}*".gsub(/\A\*+/, '*').gsub(/\*+\z/, '*'))
+        end
+
+        def move_to_quality_dir
+          ::FileUtils.mv(path.to_path, quality_dir.to_path)
+        end
+
+        private
+
+        def quality_uncached
+          package.qualities.find { |q| match_quality?(q) } || DEFAULT_QUALITY
+        end
+
+        def quality_dir
+          r = package.target_dir / quality
+          r.mkpath
+          r
+        end
+
+        def selected_dir
+          r = nil
+          r = package.target_dir / 'source' if /\.torrent/ =~ path.to_path
+          r = package.target_dir / 'subtitle' if /\.srt/ =~ path.to_path
+          raise "Destination unknown: #{path}" unless r
+
+          r.mkpath
+          r
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/extract.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Extract
+      require_sub __FILE__
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/profiles/base.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module EhbrsRubyUtils
+  module Videos2
+    module Profiles
+      module Base
+        extend ::ActiveSupport::Concern
+
+        attr_reader :convert_job
+
+        included do
+          include ActiveSupport::Callbacks
+          define_callbacks :convert, :swap
+        end
+
+        def ffmpeg_args
+          []
+        end
+
+        def on_convert_job
+          old_value = convert_job
+          begin
+            yield
+          ensure
+            self.convert_job = old_value
+          end
+        end
+
+        private
+
+        attr_writer :convert_job
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/profiles/same_quality.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'ehbrs_ruby_utils/videos2/profiles/base'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Profiles
+      module SameQuality
+        extend ::ActiveSupport::Concern
+
+        included do
+          include ::EhbrsRubyUtils::Videos2::Profiles::Base
+        end
+
+        def ffmpeg_args
+          super + ['-q:a', '0', '-q:v', '0']
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/check_result.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      class CheckResult
+        enable_simple_cache
+        common_constructor :source, :check
+
+        def passed?
+          message.blank?
+        end
+
+        private
+
+        def message_uncached
+          check.check(source)
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/check_set.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'ehbrs_ruby_utils/videos2/unsupported/checks'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      class CheckSet
+        enable_simple_cache
+        common_constructor :checks
+
+        class << self
+          # type: "file" or "track"
+          def build(profiles, type)
+            r = {}
+            profiles.each do |profile|
+              profile.send("#{type}_checks").each do |check|
+                r[check] ||= CheckWithProfiles.new(check)
+                r[check].add_profile(profile)
+              end
+            end
+            new(r.values)
+          end
+        end
+
+        class CheckWithProfiles < ::SimpleDelegator
+          def initialize(check)
+            super(check)
+            @profiles = []
+          end
+
+          def check_name
+            __getobj__.class.name.demodulize
+          end
+
+          def add_profile(profile)
+            @profiles << profile
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/check_support.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'ehbrs_ruby_utils/videos2/unsupported/check_result'
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      module CheckSupport
+        common_concern do
+          enable_simple_cache
+          enable_speaker
+        end
+
+        def aggressions_banner(title)
+          return if passed?
+
+          info title
+          pad_speaker do
+            unpassed_checks.each do |u|
+              info "* #{u.message}"
+            end
+          end
+        end
+
+        def ffmpeg_fix_args
+          unpassed_checks.flat_map do |check|
+            check.check.fix.if_present([]) { |v| v.ffmpeg_args(self) }
+          end
+        end
+
+        def passed?
+          unpassed_checks.none?
+        end
+
+        private
+
+        def unpassed_checks_uncached
+          checks.reject(&:passed?)
+        end
+
+        def checks_uncached
+          options.fetch(check_set_key).checks.map do |check|
+            ::EhbrsRubyUtils::Videos2::Unsupported::CheckResult.new(self, check)
+          end
+        rescue StandardError => e
+          raise "#{e.message} (Source: #{self})"
+        end
+
+        def fix_blocks_uncached
+          checks.reject(&:passed?).select { |c| c.check.fix.blank? }
+        end
+
+        def fixes_uncached
+          checks.reject(&:passed?).map { |c| c.check.fix }.compact_blank
+        end
+
+        def pad_speaker(&block)
+          ::EacRubyUtils::Speaker.context.on(::EacCli::Speaker.new(err_line_prefix: '  '), &block)
+        end
+
+        def new_padded_cli_speaker
+          ::EacCli::Speaker.new(
+            err_line_prefix("#{::EacRubyUtils::Speaker.context.optional_current
+            .if_present('') { |v| v.is_a?(::EacCli::Speaker) ? v.err_line_prefix : '' }}  ")
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs_ruby_utils/videos2/unsupported/checks/codec_extra_unlisted.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module EhbrsRubyUtils
+  module Videos2
+    module Unsupported
+      module Checks
+        class CodecExtraUnlisted
+          TYPE = :stream
+
+          common_constructor :codec, :listed_extras
+
+          def check(track)
+            return nil unless track.codec_name == codec
+            return nil if listed_extras.any? do |extra|
+              track.codec_tag_string.downcase.include?(extra.downcase)
+            end
+
+            "Not listed extra for codec \"#{codec}\" (Track: #{track}" \
+              ", listed extra: #{listed_extras})"
+          end
+
+          def fix
+            nil
+          end
+        end
+      end
+    end
+  end
+end