ehbrs-tools 0.25.1 → 0.28.1

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