ehbrs-tools 0.14.0 → 0.16.2

data/lib/ehbrs/videos/unsupported/checks/codec_extra_unlisted.rb

@@ -5,6 +5,8 @@ module Ehbrs
     module Unsupported
       module Checks
         class CodecExtraUnlisted
+          TYPE = :stream
+
           common_constructor :codec, :listed_extras
 
           def check(track)

data/lib/ehbrs/videos/unsupported/checks/codec_extra_unsupported.rb

@@ -7,6 +7,8 @@ module Ehbrs
     module Unsupported
       module Checks
         class CodecExtraUnsupported
+          TYPE = :stream
+
           common_constructor :codec, :extra
 
           def check(track)

data/lib/ehbrs/videos/unsupported/checks/codec_unlisted.rb

@@ -5,6 +5,8 @@ module Ehbrs
     module Unsupported
       module Checks
         class CodecUnlisted
+          TYPE = :stream
+
           common_constructor :listed_codecs
 
           def check(track)

data/lib/ehbrs/videos/unsupported/checks/codec_unsupported.rb

@@ -7,6 +7,8 @@ module Ehbrs
     module Unsupported
       module Checks
         class CodecUnsupported
+          TYPE = :stream
+
           common_constructor :codec
 
           def check(track)

data/lib/ehbrs/videos/unsupported/checks/invalid_extension.rb

@@ -7,6 +7,8 @@ module Ehbrs
     module Unsupported
       module Checks
         class InvalidExtension
+          TYPE = :container
+
           common_constructor :extension
 
           def check(video)

data/lib/ehbrs/videos/unsupported/fix_profile.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'ehbrs/videos/profiles/same_quality'
+require 'ehbrs/videos/unsupported/fixes/supported_container'
 
 module Ehbrs
   module Videos

data/lib/ehbrs/videos/unsupported/fixes/supported_codec.rb

@@ -12,7 +12,7 @@ module Ehbrs
           }.freeze
 
           TRACK_TYPE_FIX_CODECS = {
-            'Audio' => 'aac',
+            'Audio' => 'libvorbis',
             'Video' => 'libx264',
             'Subtitle' => 'ass'
           }.freeze

data/lib/ehbrs/videos/unsupported/profiles/base.rb

@@ -19,13 +19,21 @@ module Ehbrs
             added_checks << check_path.camelize.constantize.new(*args)
           end
 
+          def base_checks
+            [unlisted_codec_check] + unsupported_codec_checks +
+              supported_codecs.flat_map { |codec| codec_extra_checks(codec) }
+          end
+
+          def checks
+            base_checks + added_checks
+          end
+
           def file_checks
-            added_checks
+            checks.select { |c| check_type(c) == :container }
           end
 
           def track_checks
-            [unlisted_codec_check] + unsupported_codec_checks +
-              supported_codecs.flat_map { |codec| codec_extra_checks(codec) }
+            checks.select { |c| check_type(c) == :stream }
           end
 
           def codec_extra_checks(codec)
@@ -95,6 +103,12 @@ module Ehbrs
           def codec_supported_extras(codec)
             codec_extras(codec, 'supported')
           end
+
+          private
+
+          def check_type(check)
+            check.class.const_get(:TYPE)
+          end
         end
       end
     end

data/lib/ehbrs/videos/unsupported/profiles/philco.rb

@@ -7,19 +7,20 @@ module Ehbrs
     module Unsupported
       module Profiles
         class Philco < ::Ehbrs::Videos::Unsupported::Profiles::Base
-          AUDIO_SUPPORTED_CODECS = %w[aac ac3 eac3 mp3].freeze
-          AUDIO_UNSUPPORTED_CODECS = %w[dts].freeze
+          AUDIO_SUPPORTED_CODECS = %w[aac ac3 eac3 mp3 vorbis wmav2].freeze
+          AUDIO_UNSUPPORTED_CODECS = %w[dts opus].freeze
 
           VIDEO_SUPPORTED_CODECS = %w[h264 mpeg4].freeze
           VIDEO_UNSUPPORTED_CODECS = %w[hevc msmpeg4v3].freeze
 
-          SUBTITLE_SUPPORTED_CODECS = %w[ass dvd subrip].freeze
+          SUBTITLE_SUPPORTED_CODECS = %w[ass dvd dvd_subtitle hdmv_pgs_subtitle mov_text
+                                         subrip].freeze
           SUBTITLE_UNSUPPORTED_CODECS = %w[mov].freeze
 
           OTHER_SUPPORTED_CODECS = %w[png ttf].freeze
 
           MPEG4_EXTRA_SUPPORTED = %w[xvid].freeze
-          MPEG4_EXTRA_UNSUPPORTED = %w[dx50].freeze
+          MPEG4_EXTRA_UNSUPPORTED = %w[divx dx50].freeze
         end
       end
     end

data/vendor/aranha-parsers/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/vendor/aranha-parsers/aranha-parsers.gemspec

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+require 'aranha/parsers/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'aranha-parsers'
+  s.version     = ::Aranha::Parsers::VERSION
+  s.authors     = ['Esquilo Azul Company']
+  s.summary     = 'Parsers\' utilities for Ruby.'
+
+  s.files = Dir['{lib}/**/*', 'Gemfile']
+
+  s.add_dependency 'activesupport', '>= 4.0.0'
+  s.add_dependency 'addressable', '~> 2.7'
+  s.add_dependency 'curb', '~> 0.9.10'
+  s.add_dependency 'eac_ruby_utils', '~> 0.33', '>= 0.33.1'
+  s.add_dependency 'httpclient', '~> 2.8', '>= 2.8.3'
+  s.add_dependency 'ofx-parser', '~> 1.1.0'
+
+  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.1'
+end

data/vendor/aranha-parsers/lib/aranha/parsers.rb

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

data/vendor/aranha-parsers/lib/aranha/parsers/base.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'open-uri'
+require 'fileutils'
+require 'aranha/parsers/source_address'
+require 'eac_ruby_utils/fs/temp'
+
+module Aranha
+  module Parsers
+    class Base
+      class << self
+        def from_content(content)
+          ::EacRubyUtils::Fs::Temp.on_file do |path|
+            path.write(content)
+            r = new(path.to_path)
+            r.content
+            r
+          end
+        end
+
+        def parse_content(content)
+          from_content(content).data
+        end
+      end
+
+      LOG_DIR_ENVVAR = 'ARANHA_PARSERS_LOG_DIR'
+
+      attr_reader :source_address
+
+      def initialize(url)
+        @source_address = ::Aranha::Parsers::SourceAddress.new(url)
+        log_content(source_address.serialize, '-source-address')
+      end
+
+      delegate :url, to: :source_address
+
+      def content
+        @content ||= begin
+          s = source_address.content
+          log_content(s)
+          s
+        end
+      end
+
+      private
+
+      def log_content(content, suffix = '')
+        path = log_file(suffix)
+
+        return unless path
+
+        File.open(path, 'wb') { |file| file.write(content) }
+      end
+
+      def log_file(suffix)
+        dir = log_parsers_dir
+        return nil unless dir
+
+        f = ::File.join(dir, "#{self.class.name.parameterize}#{suffix}.log")
+        FileUtils.mkdir_p(File.dirname(f))
+        f
+      end
+
+      def log_parsers_dir
+        return ENV[LOG_DIR_ENVVAR] if ENV[LOG_DIR_ENVVAR]
+        return ::Rails.root.join('log', 'parsers') if rails_root_exist?
+
+        nil
+      end
+
+      def rails_root_exist?
+        ::Rails.root
+        true
+      rescue NameError
+        false
+      end
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/html.rb

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

data/vendor/aranha-parsers/lib/aranha/parsers/html/base.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'aranha/parsers/base'
+require 'aranha/parsers/html/node/default'
+
+module Aranha
+  module Parsers
+    module Html
+      class Base < ::Aranha::Parsers::Base
+        class << self
+          def fields
+            @fields ||= []
+            @fields.dup
+          end
+
+          def field(name, type, xpath)
+            @fields ||= []
+            @fields << Field.new(name, type, xpath)
+          end
+
+          Field = Struct.new(:name, :type, :xpath)
+        end
+
+        def nokogiri
+          @nokogiri ||= Nokogiri::HTML(content, &:noblanks)
+        end
+
+        protected
+
+        def node_parser_class
+          ::Aranha::Parsers::Html::Node::Default
+        end
+
+        private
+
+        def node_parser
+          @node_parser ||= node_parser_class.new(fields)
+        end
+
+        def fields
+          self.class.fields.map { |f| [f.name, f.type, f.xpath] }
+        end
+      end
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/html/item.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'aranha/parsers/html/base'
+
+module Aranha
+  module Parsers
+    module Html
+      class Item < Base
+        def data
+          @data ||= node_parser.parse(item_node)
+        end
+
+        def item_node
+          @item_node ||= begin
+            r = item_xpath ? nokogiri.at_xpath(item_xpath) : nokogiri
+            raise "Item node not found (Item xpath: #{item_xpath})" unless r
+
+            r
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/html/item_list.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'aranha/parsers/html/base'
+
+module Aranha
+  module Parsers
+    module Html
+      class ItemList < Base
+        def data
+          items_data
+        end
+
+        def items_data
+          count = 0
+          @data ||= nokogiri.xpath(items_xpath).map do |m|
+            count += 1
+            node_parser.parse(m)
+          end
+        rescue StandardError => e
+          raise StandardError, "#{e.message} (Count: #{count})"
+        end
+
+        def items_xpath
+          raise "Class #{self.class} has no method \"#{__method__}\". Implement it"
+        end
+      end
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/html/node.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+
+module Aranha
+  module Parsers
+    module Html
+      module Node
+        ::EacRubyUtils.require_sub __FILE__
+      end
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/html/node/base.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Aranha
+  module Parsers
+    module Html
+      module Node
+        class Base
+          attr_reader :fields
+
+          def initialize(fields)
+            @fields = fields
+          end
+
+          def parse(node)
+            fields.map do |f|
+              begin
+                [f[0], parse_field(node, f[2], f[1])]
+              rescue StandardError => e
+                raise StandardError, "#{e.message}\nFields: #{f}"
+              end
+            end.to_h
+          end
+
+          private
+
+          def parse_field(node, xpath, parser_method)
+            value_method = "#{parser_method}_value"
+            return send(value_method, node, xpath) if respond_to?(value_method)
+
+            raise "Method \"#{value_method}\" not found in #{self.class}"
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/html/node/default.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'aranha/parsers/html/node/base'
+
+module Aranha
+  module Parsers
+    module Html
+      module Node
+        class Default < ::Aranha::Parsers::Html::Node::Base
+          def string_value(node, xpath)
+            if node.at_xpath(xpath)
+              sanitize_string(node.at_xpath(xpath).text)
+            else
+              ''
+            end
+          end
+
+          def string_recursive_value(node, xpath, required = true)
+            root = node.at_xpath(xpath)
+            if root.blank?
+              return nil unless required
+
+              raise "No node found (Xpath: #{xpath})"
+            end
+            result = string_recursive(root)
+            return result if result.present?
+            return nil unless required
+
+            raise "String blank (Xpath: #{xpath})"
+          end
+
+          def string_recursive_optional_value(node, xpath)
+            string_recursive_value(node, xpath, false)
+          end
+
+          def quoted_value(node, xpath)
+            s = string_value(node, xpath)
+            return '' unless s
+
+            m = /\"([^\"]+)\"/.match(s)
+            return m[1] if m
+
+            ''
+          end
+
+          def integer_value(node, xpath)
+            r = string_value(node, xpath)
+            return nil if r.blank?
+
+            m = /\d+/.match(r)
+            raise "Integer not found in \"#{r}\"" unless m
+
+            m[0].to_i
+          end
+
+          def integer_optional_value(node, xpath)
+            r = string_value(node, xpath)
+            m = /\d+/.match(r)
+            m ? m[0].to_i : nil
+          end
+
+          def float_value(node, xpath)
+            parse_float(node, xpath, true)
+          end
+
+          def float_optional_value(node, xpath)
+            parse_float(node, xpath, false)
+          end
+
+          def array_value(node, xpath)
+            r = node.xpath(xpath).map { |n| n.text.strip }
+            r.join('|')
+          end
+
+          def join_value(node, xpath)
+            m = ''
+            node.xpath(xpath).each do |n|
+              m << n.text.strip
+            end
+            m
+          end
+
+          def duration_value(node, xpath)
+            m = /(\d+) m/.match(join_value(node, xpath))
+            m ? m[1].to_i : nil
+          end
+
+          def regxep(node, xpath, pattern)
+            s = string_value(node, xpath)
+            m = pattern.match(s)
+            return m if m
+
+            raise "Pattern \"#{pattern}\" not found in string \"#{s}\""
+          end
+
+          private
+
+          def parse_float(node, xpath, required)
+            s = string_value(node, xpath)
+            m = /\d+(?:[\.\,](\d+))?/.match(s)
+            if m
+              m[0].delete('.').tr(',', '.').to_f
+            elsif required
+              raise "Float value not found in \"#{s}\""
+            end
+          end
+
+          def sanitize_string(obj)
+            obj.to_s.tr("\u00A0", ' ').strip
+          end
+
+          def string_recursive(node)
+            return sanitize_string(node.text) if node.is_a?(::Nokogiri::XML::Text)
+
+            s = ''
+            node.children.each do |child|
+              child_s = string_recursive(child)
+              s += ' ' + child_s if child_s.present?
+            end
+            sanitize_string(s)
+          end
+        end
+      end
+    end
+  end
+end