vk_music 3.1.7 → 4.1.0

data/lib/vk_music/request/search.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Request
+    # Logging in request
+    class Search < Base
+      # Initialize new request
+      # @param query [String]
+      # @param client_id [Integer]
+      def initialize(query, client_id)
+        @client_id = client_id
+        super(
+          "#{VK_ROOT}/audio",
+          { q: query, _ajax: 1 },
+          'POST',
+          { 'content-type' => 'application/x-www-form-urlencoded', 'x-requested-with' => 'XMLHttpRequest' }
+        )
+      end
+
+      def_delegators :@parser, :audios, :audios_all_path, :playlists, :playlists_all_path
+
+      private
+
+      def after_call
+        json = JSON.parse(@response.body.strip)
+        raise 'Captcha requested' if json['key'] == 'captcha_key'
+
+        inner = json['data'][2]
+        html = Nokogiri::HTML.fragment(CGI.unescapeElement(inner))
+        @parser = WebParser::Search.new(html)
+      end
+    end
+  end
+end

data/lib/vk_music/request/wall_section.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Request
+    # Wall in JSON sections request
+    class WallSection < Base
+      # Initialize new request
+      # @param owner_id [Integer]
+      # @param post_id [Integer]
+      # @param offset [Integer]
+      # @param client_id [Integer]
+      def initialize(owner_id, post_id, client_id)
+        @client_id = client_id
+        super(
+          "#{VK_ROOT}/audio",
+          {
+            act: 'load_section', type: 'wall', utf8: true,
+            owner_id: owner_id, post_id: post_id, wall_type: 'own'
+          },
+          'GET',
+          {}
+        )
+      end
+
+      def_delegators :@parser, :audios, :title, :subtitle, :real_size, :more?
+
+      private
+
+      def after_call
+        @parser = WebParser::WallSection.new(@response, client_id: @client_id)
+      end
+    end
+  end
+end

data/lib/vk_music/utility.rb

@@ -1,78 +1,8 @@
-require_relative "utility/log"
-
-module VkMusic
-  ##
-  # Utility methods.
-  module Utility
-    ##
-    # Turn amount of seconds into string.
-    # @param s [Integer] amount of seconds.
-    # @return [String] formatted string.
-    def self.format_seconds(s)
-      s = s.to_i # Require integer
-      "#{(s / 60).to_s.rjust(2, "0")}:#{(s % 60).to_s.rjust(2, "0")}";
-    end
-
-    ##
-    # Guess type of request by from string.
-    #
-    # Possible results:
-    # * +:playlist+ - if string match playlist URL.
-    # * +:post+ - if string match post URL.
-    # * +:audios+ - if string match user or group URL.
-    # * +:find+ - in rest of cases.
-    # @param str [String] request from user for some audios.
-    # @return [Symbol]
-    def self.guess_request_type(str)
-      case str
-        when Constants::Regex::VK_PLAYLIST_URL_POSTFIX
-          :playlist
-        when Constants::Regex::VK_WALL_URL_POSTFIX, Constants::Regex::VK_POST_URL_POSTFIX
-          :post
-        when Constants::Regex::VK_BLOCK_URL
-          :block
-        when Constants::Regex::VK_URL
-          :audios
-        else
-          :find
-      end
-    end
-
-    ##
-    # Turn hash into URL query string.
-    # @param hash [Hash]
-    # @return [String]
-    def self.hash_to_params(hash = {})
-      qs = ""
-      hash.each_key do |key|
-        qs << "&" unless qs.empty?
-        case hash[key]
-          when Array
-            qs << CGI.escape(key.to_s) << "=" << hash[key].map { |value| CGI.escape(value.to_s) }.join(",")
-          else
-            qs << CGI.escape(key.to_s) << "=" << CGI.escape(hash[key].to_s)
-        end
-      end
-      qs
-    end
-
-    ##
-    # Get content of text children of provided Node.
-    # @param node [Nokogiri::Xml::Node]
-    # @return [String]
-    def self.plain_text(node)
-      node.children.select(&:text?).map(&:text).join ""
-    end
-
-    ##
-    # Turn human readable track length to its size in seconds.
-    # @param str [String] string in format "HH:MM:SS" or something alike (+/d++ Regex selector is used).
-    # @return [Integer] amount of seconds.
-    def self.parse_duration(str)
-      str.scan(/\d+/)
-         .map(&:to_i)
-         .reverse
-         .each_with_index.reduce(0) { |m, arr| m + arr[0] * 60**arr[1] }
-    end
-  end
-end
+# frozen_string_literal: true
+
+module VkMusic
+  # Helpers
+  module Utility; end
+end
+
+Dir[File.join(__dir__, 'utility', '*.rb')].each { |file| require_relative file }

data/lib/vk_music/utility/artist_loader.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Load artist top audios
+    module ArtistLoader
+      # @param agent [Mechanize]
+      # @param client_id [Integer]
+      # @param name [String]
+      # @return [Array<Audio>]
+      def self.call(agent, client_id, name)
+        page = Request::Artist.new(name, client_id).call(agent)
+        page.audios
+      end
+    end
+  end
+end

data/lib/vk_music/utility/artist_url_parser.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Artist URL parser
+    module ArtistUrlParser
+      # Regex for artist URL
+      ARTIST_POSTFIX = %r{.*artist/([\w.\-~]+)}.freeze
+      public_constant :ARTIST_POSTFIX
+
+      # Get artist name based on provided URL
+
+      # @param url [String]
+      # @return [String?]
+      def self.call(url)
+        url.match(ARTIST_POSTFIX)&.captures&.first
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/vk_music/utility/audio_data_parser.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Parse {Audio} from +Array+ of audio data
+    module AudioDataParser
+      class << self
+        # @param data [Array]
+        # @param client_id [Integer]
+        # @return [Audio]
+        def call(data, client_id)
+          url_encoded = get_url_encoded(data)
+          _add_hash, _edit_hash, _action_hash, _delete_hash, _teplace_hash, url_hash = get_secrets(data)
+
+          Audio.new(id: data[0], owner_id: data[1],
+                    secret1: url_hash, secret2: url_hash,
+                    artist: CGI.unescapeHTML(data[4]), title: CGI.unescapeHTML(data[3]),
+                    duration: data[5],
+                    url_encoded: url_encoded, url: nil, client_id: client_id)
+        end
+
+        private
+
+        def get_url_encoded(data)
+          url_encoded = data[2].to_s
+          url_encoded = nil if url_encoded.empty?
+
+          url_encoded
+        end
+
+        def get_secrets(data)
+          data[13].to_s.split('/')
+        end
+      end
+    end
+  end
+end

data/lib/vk_music/utility/audio_items_parser.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Parse {Audio} from +Nokogiri::XML::Node+
+    module AudioItemsParser
+      # @param node [Nokogiri::XML::Node]
+      # @param client_id [Integer]
+      # @return [Array<Audio>]
+      def self.call(node, client_id)
+        node.css('.audio_item.ai_has_btn,.audio_item.audio_item_disabled').map do |elem|
+          data = JSON.parse(elem.attribute('data-audio').value)
+          Utility::AudioDataParser.call(data, client_id)
+        end
+      end
+    end
+  end
+end

data/lib/vk_music/utility/audio_node_parser.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Parse {Audio} from +Nokogiri::XML::Node+
+    module AudioNodeParser
+      class << self
+        # @param node [Nokogiri::XML::Node]
+        # @param client_id [Integer]
+        # @return [Audio]
+        def call(node, client_id)
+          input = node.at_css('input')
+          if input
+            parse_input(input, node, client_id)
+          else
+            parse_post(node, client_id)
+          end
+        end
+
+        private
+
+        def parse_input(input, node, client_id)
+          id_array = get_id_array(node)
+          artist, title, duration = get_main_data(node)
+
+          Audio.new(id: Integer(id_array[1], 10), owner_id: Integer(id_array[0], 10),
+                    artist: artist, title: title, duration: duration,
+                    url_encoded: get_encoded_url(input), url: nil, client_id: client_id)
+        end
+
+        def get_encoded_url(input)
+          url_encoded = input.attribute('value').to_s
+          url_encoded = nil if url_encoded.empty? || url_encoded == Constants::URL::VK[:audio_unavailable]
+
+          url_encoded
+        end
+
+        def get_id_array(node)
+          node.attribute('data-id').to_s.split('_')
+        end
+
+        def get_main_data(node)
+          [
+            node.at_css('.ai_artist').text.strip,
+            node.at_css('.ai_title').text.strip,
+            Integer(node.at_css('.ai_dur').attribute('data-dur').to_s, 10)
+          ]
+        end
+
+        def parse_post(node, client_id)
+          artist = node.at_css('.medias_music_author').text.strip
+          title = NodeTextChildrenReader.call(node.at_css('.medias_audio_title'))
+          duration = DurationParser.call(node.at_css('.medias_audio_dur').text)
+          Audio.new(artist: artist, title: title, duration: duration, client_id: client_id)
+        end
+      end
+    end
+  end
+end

data/lib/vk_music/utility/audios_from_ids_loader.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Load audios from ids
+    module AudiosFromIdsLoader
+      # @param agent [Mechanize]
+      # @param ids [Array<String>]
+      # @return [Array<Audio>]
+      def self.call(agent, ids, client_id)
+        audios = []
+        ids.each_slice(10) do |subarray|
+          page = Request::AudiosReload.new(subarray, client_id)
+          page.call(agent)
+          audios.concat(page.audios)
+        end
+        audios
+      end
+    end
+  end
+end

data/lib/vk_music/utility/audios_ids_getter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Load ids from array of data
+    module AudiosIdsGetter
+      # @param args [Array<Audio, (owner_id, audio_id, secret_1, secret_2),
+      #   "#{owner_id}_#{id}_#{secret_1}_#{secret_2}">]
+      # @return [Array<String>] array of uniq full ids
+      def self.call(args)
+        ids = args.map do |item|
+          case item
+          when Audio then item.full_id
+          when Array then item.join('_')
+          when String then item
+          end
+        end
+        ids.compact!
+        ids.uniq!
+
+        ids
+      end
+    end
+  end
+end

data/lib/vk_music/utility/audios_loader.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Load user or group audios
+    module AudiosLoader
+      class << self
+        # @param agent [Mechanize]
+        # @param client_id [Integer]
+        # @param owner_id [Integer]
+        # @param up_to [Integer]
+        # @return [Playlist?]
+        def call(agent, client_id, owner_id, up_to)
+          page = Request::PlaylistSection.new(owner_id, -1, '', 0, client_id).call(agent)
+          audios = page.audios
+          return if audios.nil? || audios.empty?
+
+          up_to = page.real_size if up_to > page.real_size
+
+          load_till_up_to(audios, agent, client_id, owner_id, up_to)
+
+          Playlist.new(audios, id: -1, owner_id: owner_id, access_hash: '',
+                               title: page.title, subtitle: page.subtitle, real_size: page.real_size)
+        end
+
+        private
+
+        def load_till_up_to(audios, agent, client_id, owner_id, up_to)
+          return audios.slice!(up_to..) if up_to <= audios.size
+
+          rest = PlaylistSectionLoader.call(agent, client_id, owner_id, -1, '', audios.size, up_to - audios.size)
+          audios.concat(rest)
+        end
+      end
+    end
+  end
+end

data/lib/vk_music/utility/data_type_guesser.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'playlist_url_parser'
+require_relative 'post_url_parser'
+
+module VkMusic
+  module Utility
+    # Guess type of method to use based on string data
+    module DataTypeGuesser
+      # End of playlist URL
+      PLAYLIST_POSTFIX = PlaylistUrlParser::VK_PLAYLIST_URL_POSTFIX
+      public_constant :PLAYLIST_POSTFIX
+
+      # Artist URL postfix
+      ARTIST_POSTFIX = ArtistUrlParser::ARTIST_POSTFIX
+      public_constant :ARTIST_POSTFIX
+
+      # End of post URL
+      POST_POSTFIX = PostUrlParser::POST_POSTFIX
+      public_constant :POST_POSTFIX
+
+      # End of wall URL
+      WALL_POSTFIX = /.*wall(-?\d+)/.freeze
+      public_constant :WALL_POSTFIX
+
+      # End of profile audios URL
+      AUDIOS_POSTFIX = /.*audios(-?\d+)/.freeze
+      public_constant :AUDIOS_POSTFIX
+
+      # Full profile URL regex
+      PROFILE_URL = %r{(?:https?://)?(?:vk\.com/)([^/?&]+)}.freeze
+      public_constant :PROFILE_URL
+
+      # @param data [String]
+      # @return [Symbol]
+      def self.call(data)
+        case data
+        when PLAYLIST_POSTFIX then :playlist
+        when ARTIST_POSTFIX then :artist
+        when POST_POSTFIX then :post
+        when WALL_POSTFIX then :wall
+        when AUDIOS_POSTFIX, PROFILE_URL then :audios
+        else :find
+        end
+      end
+    end
+  end
+end