ehbrs-tools 0.25.0 → 0.28.0

data/vendor/ultimate_lyrics/bin/download_parser_spec_files.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+ENV['BUNDLE_GEMFILE'] = ::File.expand_path('../Gemfile', __dir__)
+require 'rubygems'
+require 'bundler/setup'
+$LOAD_PATH.unshift("#{__dir__}/../lib")
+
+require 'ultimate_lyrics/song_metadata'
+require 'ultimate_lyrics/provider'
+require 'ultimate_lyrics/provider_search'
+require 'aranha/parsers/source_address'
+require 'aranha/parsers/source_address/fetch_content_error'
+require 'eac_ruby_utils/core_ext'
+
+class OriginalContentDownload
+  enable_simple_cache
+  common_constructor :song_metadata, :provider
+
+  def run
+    puts "Fetch content for #{provider_search}..."
+    source_content.if_present do |v|
+      source_file.write(v)
+      url_file.write(provider_search.url.strip + "\n")
+    end
+  end
+
+  private
+
+  def basename_file_uncached
+    provider.name.variableize + '__' + "#{song_metadata.artist}_#{song_metadata.title}".variableize
+  end
+
+  def fixtures_dir_uncached
+    __dir__.to_pathname.parent.join('spec', 'lib', 'ultimate_lyrics', 'parser_spec_files')
+  end
+
+  def provider_search_uncached
+    ::UltimateLyrics::ProviderSearch.new(provider, song_metadata)
+  end
+
+  def source_content
+    r = ::Aranha::Parsers::SourceAddress.detect_sub(provider_search.url).content
+    puts 'SUCCESS: content fetched'
+    r
+  rescue ::Aranha::Parsers::SourceAddress::FetchContentError => e
+    puts "ERROR: #{e.message}"
+    nil
+  end
+
+  def source_file
+    fixtures_dir.join("#{basename_file}.source.html")
+  end
+
+  def url_file
+    fixtures_dir.join("#{basename_file}.url")
+  end
+end
+
+class OriginalContentDownloads
+  SONG_METADATAS = [{
+    artist: 'Michael Jackson',
+    title: 'Thriller',
+    album: 'Thriller',
+    track: '4',
+    year: '1982'
+  }, {
+    artist: 'Milton Nascimento',
+    title: 'Rouxinol',
+    album: 'Nascimento',
+    track: '5',
+    year: '1997'
+  }].freeze
+
+  def run
+    downloads.each(&:run)
+  end
+
+  def downloads
+    song_metadatas.lazy.flat_map do |song_metadata|
+      providers.map { |provider| ::OriginalContentDownload.new(song_metadata, provider) }
+    end
+  end
+
+  def song_metadatas
+    SONG_METADATAS.map { |data| ::UltimateLyrics::SongMetadata.new(data) }
+  end
+
+  def providers
+    ::UltimateLyrics::Provider.all
+  end
+end
+
+::OriginalContentDownloads.new.run

data/vendor/ultimate_lyrics/lib/ultimate_lyrics/field.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module UltimateLyrics
+  class Field
+    DATA = {
+      'artist' => %w[artist lower],
+      'artist2' => %w[artist lower nospace],
+      'album' => %w[album lower],
+      'album2' => %w[album lower nospace],
+      'title' => %w[title lower],
+      'Artist' => %w[artist],
+      'Album' => %w[album],
+      'ARTIST' => %w[artist upper],
+      'year' => %w[year pretty],
+      'Title' => %w[title],
+      'Title2' => %w[title titlecase],
+      'a' => %w[artist firstchar],
+      'track' => %w[track number]
+    }.freeze
+
+    BEGIN_DELIMITER = '{'
+    END_DELIMITER = '}'
+
+    class << self
+      # @return [Array<UltimateLyrics::Field>]
+      def all
+        @all ||= DATA.map do |name, modifiers|
+          source_attr = modifiers.shift
+          new(name, source_attr, modifiers)
+        end
+      end
+
+      # @return [UltimateLyrics::Field]
+      def by_name(name)
+        all.find { |field| field.name == name } ||
+          raise("No field with name \"#{name}\" (Available: #{all.values})")
+      end
+
+      # @return [Array<UltimateLyrics::Field>]
+      def from_string(string)
+        names_from_string(string).map { |name| by_name(name) }
+      end
+
+      # @return [Array<String>]
+      def names_from_string(string)
+        string.scan(/#{::Regexp.quote(BEGIN_DELIMITER)}[^\}]+#{::Regexp.quote(END_DELIMITER)}/)
+              .map { |s| s.delimited_inner(BEGIN_DELIMITER, END_DELIMITER) }
+      end
+    end
+
+    common_constructor :name, :source_attribute, :modifiers
+
+    def apply(string, value)
+      string.gsub(apply_pattern, value)
+    end
+
+    def apply_pattern
+      /#{::Regexp.quote(BEGIN_DELIMITER)}#{::Regexp.quote(name)}#{::Regexp.quote(END_DELIMITER)}/
+    end
+
+    def value(value)
+      modifiers.inject(value.to_s) { |a, e| send(e, a) }
+    end
+
+    def to_s
+      name
+    end
+
+    private
+
+    def firstchar(string)
+      string[0]
+    end
+
+    def lower(string)
+      string.downcase
+    end
+
+    def nospace(string)
+      string.gsub(/\s/, '')
+    end
+  end
+end

data/vendor/ultimate_lyrics/lib/ultimate_lyrics/lyrics.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module UltimateLyrics
+  class Lyrics
+    common_constructor :song_metadata, :provider_name, :text
+
+    def found?
+      text.present?
+    end
+  end
+end

data/vendor/ultimate_lyrics/lib/ultimate_lyrics/parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module UltimateLyrics
+  class Parser
+    common_constructor :provider, :original_content
+
+    def original_content_invalid?
+      provider.invalid_indicators.any? { |v| original_content.include?(v) }
+    end
+
+    def result
+      return nil if original_content_invalid?
+
+      sanitize_text(provider.rules.inject(original_content) { |a, e| e.apply(a) })
+    end
+
+    def sanitize_text(text)
+      r = text.to_s.gsub("\t", ' ').gsub("\r", '').gsub(/ +/, ' ').gsub(/\n{2,}/m, "\n\n").strip
+      r.present? ? "#{r}\n" : nil
+    end
+
+    def url?
+      provider.extract_rules.any?(&:url?)
+    end
+  end
+end

data/vendor/ultimate_lyrics/lib/ultimate_lyrics/provider/exclude_item.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'ultimate_lyrics/provider/item'
+
+module UltimateLyrics
+  class Provider
+    class ExcludeItem < ::UltimateLyrics::Provider::Item
+      def apply_from_delimiters(source)
+        source.delimited_without_outer(begin_with, end_with)
+      end
+
+      def apply_from_tag(source)
+        source.delimited_without_outer(tag, "</#{tag_name}>")
+      end
+    end
+  end
+end

data/vendor/ultimate_lyrics/lib/ultimate_lyrics/provider/extract_item.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'ultimate_lyrics/provider/item'
+
+module UltimateLyrics
+  class Provider
+    class ExtractItem < ::UltimateLyrics::Provider::Item
+      def apply_from_delimiters(source)
+        source.delimited_inner(begin_with, end_with)
+      end
+
+      def apply_from_tag(source)
+        source.delimited_inner(tag, "</#{tag_name}>")
+      end
+
+      def apply_from_url(source)
+        url.gsub('{id}', source)
+      end
+    end
+  end
+end

data/vendor/ultimate_lyrics/lib/ultimate_lyrics/provider/item.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module UltimateLyrics
+  class Provider
+    class Item
+      METHODS_ATTRIBUTES = { tag: :tag, begin_with: :begin, end_with: :end, url: :url }.freeze
+      TAG_NAME_PARSER = /<(\w+).*>/.to_parser { |m| m[1] }
+
+      common_constructor :rule, :node
+
+      METHODS_ATTRIBUTES.each do |method_name, attr|
+        define_method method_name do
+          ::CGI.unescapeHTML(node.attribute(attr.to_s).if_present('', &:text)).presence
+        end
+
+        define_method "#{method_name}?" do
+          send(method_name).present?
+        end
+      end
+
+      def delimiters?
+        begin_with? || end_with?
+      end
+
+      def apply(source)
+        %w[url tag delimiters].each do |m|
+          next unless send("#{m}?")
+
+          return send("apply_from_#{m}", source)
+        end
+
+        raise 'Invalid branch hit'
+      end
+
+      def tag_name
+        TAG_NAME_PARSER.parse(tag)
+      end
+
+      def to_s
+        self.class.name.demodulize + '[' + METHODS_ATTRIBUTES
+                                           .select { |m, _a| send(m).present? }
+                                           .map { |m, a| "#{a}: #{send(m)}" }
+                                           .join(', ') +
+          ']'
+      end
+    end
+  end
+end

data/vendor/ultimate_lyrics/lib/ultimate_lyrics/provider/replace_fields.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module UltimateLyrics
+  class Provider
+    class ReplaceFields
+      common_constructor :metadata, :source_string
+
+      def result
+        fields_found.inject(source_string) { |a, e| a.gsub("{#{e}}", metadata.send(e)) }
+      end
+    end
+  end
+end

data/vendor/ultimate_lyrics/lib/ultimate_lyrics/provider/rule.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module UltimateLyrics
+  class Provider
+    class Rule
+      common_constructor :node
+
+      def items
+        node.xpath('./item').map { |v| item_class.new(self, v) }
+      end
+
+      def item_class
+        ::UltimateLyrics::Provider.const_get(type.camelize + 'Item')
+      end
+
+      def apply(string)
+        url? ? apply_with_url(string) : apply_without_url(string)
+      end
+
+      def to_s
+        "Rule[#{type} | #{items.join(', ')}]"
+      end
+
+      def type
+        node.name
+      end
+
+      def url?
+        items.any?(&:url?)
+      end
+
+      private
+
+      def apply_without_url(string)
+        items.inject(string) { |a, e| e.apply(a) }
+      end
+
+      def apply_with_url(string)
+        url_item, id_item = url_items
+        id_item.apply(string).if_present { |v| url_item.apply(v) }
+      end
+
+      def url_items
+        raise "There is more than 2 items in #{rule}" if items.count != 2
+
+        url_item = items.find(&:url?) || raise("No URL item found in #{rule}")
+        id_item = items.find(&:delimiters?) || raise("No ID item found in #{rule}")
+        [url_item, id_item]
+      end
+    end
+  end
+end

data/vendor/ultimate_lyrics/lib/ultimate_lyrics/provider/url_format.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module UltimateLyrics
+  class Provider
+    class UrlFormat
+      common_constructor :node
+
+      def apply(value)
+        replace_chars.inject(value) { |a, e| a.gsub(e, with) }
+      end
+
+      def replace_chars
+        ::CGI.unescapeHTML(node.attribute('replace').text).each_char.to_a
+      end
+
+      def with
+        node.attribute('with').text
+      end
+    end
+  end
+end

data/vendor/ultimate_lyrics/lib/ultimate_lyrics/provider.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'nokogiri'
+require 'ultimate_lyrics/field'
+
+module UltimateLyrics
+  class Provider
+    require_sub __FILE__
+
+    class << self
+      # @return [Array<UltimateLyrics::Provider>]
+      def all
+        @all ||= ::Nokogiri::XML(
+          ::File.new(::File.join(__dir__, 'providers_data.xml'))
+        ).xpath('/lyricproviders/provider').map { |node| new(node) }
+      end
+
+      # @return [UltimateLyrics::Provider]
+      def by_name(name)
+        by_attribute('name', name)
+      end
+
+      # @return [UltimateLyrics::Provider]
+      def by_identifier(identifier)
+        by_attribute('identifier', identifier)
+      end
+
+      # @return [UltimateLyrics::Provider]
+      def by_attribute(attribute, value)
+        all.find { |provider| provider.send(attribute) == value } ||
+          raise("No provider with name \"#{value}\" (Available: " +
+            all.map { |p| p.send(attrbute) }.join(', ') + ')')
+      end
+    end
+
+    common_constructor :node
+
+    def encoding
+      node.attribute('charset').text
+    end
+
+    def extract_rules
+      node.xpath('./extract').map do |v|
+        ::UltimateLyrics::Provider::Rule.new(v)
+      end
+    end
+
+    def exclude_rules
+      node.xpath('./exclude').map do |v|
+        ::UltimateLyrics::Provider::Rule.new(v)
+      end
+    end
+
+    def identifier
+      name.variableize
+    end
+
+    def invalid_indicators
+      node.xpath('/invalidIndicator/@value').map(&:text)
+    end
+
+    # @return [String]
+    def name
+      node.attribute('name').text
+    end
+
+    def rules
+      extract_rules + exclude_rules
+    end
+
+    # @return [String]
+    def url
+      node.attribute('url').text
+    end
+
+    # @return [Array<UltimateLyrics::Field>]
+    def url_fields
+      ::UltimateLyrics::Field.from_string(url)
+    end
+
+    def url_formats
+      node.xpath('./urlFormat').map do |v|
+        ::UltimateLyrics::Provider::UrlFormat.new(v)
+      end
+    end
+
+    def title
+      node.attribute('text').text
+    end
+
+    def to_s
+      name
+    end
+  end
+end

data/vendor/ultimate_lyrics/lib/ultimate_lyrics/provider_search.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'aranha/parsers/source_address'
+require 'eac_ruby_utils/core_ext'
+require 'ultimate_lyrics/lyrics'
+require 'ultimate_lyrics/parser'
+
+module UltimateLyrics
+  class ProviderSearch
+    common_constructor :provider, :song_metadata
+
+    # @return [String]
+    def url
+      url_fields.inject(provider.url) { |a, e| e.apply(a) }
+    end
+
+    # @return []
+    def url_fields
+      provider.url_fields.map { |provider_url_field| song_metadata.field(provider_url_field) }
+    end
+
+    # @return [UltimateLyrics::Lyrics]
+    def lyrics
+      ::UltimateLyrics::Lyrics.new(song_metadata, provider.name, parser.result)
+    end
+
+    # @return [UltimateLyrics::Parser]
+    def lyrics_original_text
+      ::Aranha::Parsers::SourceAddress.detect_sub(url).content.force_encoding(provider.encoding)
+    rescue ::Aranha::Parsers::SourceAddress::FetchContentError
+      nil
+    end
+
+    # @return [UltimateLyrics::Parser]
+    def parser
+      ::UltimateLyrics::Parser.new(provider, lyrics_original_text)
+    end
+
+    def to_s
+      "ProviderSearch[#{provider} | #{song_metadata}]"
+    end
+  end
+end