vk_music 3.1.3 → 4.0.0

data/lib/vk_music/utility/node_text_children_reader.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Read inner of text-childrens of +Nokogiri::XML::Node+ node
+    class NodeTextChildrenReader
+      # @param node [Nokogiri::XML::Node]
+      # @return [String]
+      def self.call(node)
+        node.children.select(&:text?).map(&:text).join('').strip
+      end
+    end
+  end
+end

data/lib/vk_music/utility/playlist_loader.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Load playlist audios
+    class PlaylistLoader
+      # @param agent [Mechanize]
+      # @param client_id [Integer]
+      # @param owner_id [Integer]
+      # @param playlist_id [Integer]
+      # @param access_hash [String, nil]
+      # @param up_to [Integer]
+      # @return [Playlist?]
+      def self.call(agent, client_id, owner_id, playlist_id, access_hash, up_to)
+        page = Request::Playlist.new(owner_id, playlist_id, access_hash, client_id)
+        page.call(agent)
+        audios = page.audios
+        return if audios.nil? || audios.empty?
+
+        up_to = page.real_size if up_to > page.real_size
+
+        rest = PlaylistSectionLoader.call(agent, client_id, owner_id, playlist_id, access_hash,
+                                          audios.size, up_to - audios.size)
+        audios.concat(rest)
+        Playlist.new(audios, id: playlist_id, owner_id: owner_id, access_hash: access_hash,
+                             title: page.title, subtitle: page.subtitle, real_size: page.real_size)
+      end
+    end
+  end
+end

data/lib/vk_music/utility/playlist_node_parser.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Read inner of text-childrens of +Nokogiri::XML::Node+ node
+    class PlaylistNodeParser
+      # @param node [Nokogiri::XML::Node]
+      # @return [Playlist]
+      def self.call(node)
+        url = node.at_css('.audioPlaylists__itemLink').attribute('href').value
+        owner_id, id, access_hash = PlaylistUrlParser.call(url)
+
+        Playlist.new([],
+                     id: id, owner_id: owner_id, access_hash: access_hash,
+                     title: node.at_css('.audioPlaylists__itemTitle').content,
+                     subtitle: node.at_css('.audioPlaylists__itemSubtitle').content,
+                     real_size: nil)
+      end
+    end
+  end
+end

data/lib/vk_music/utility/playlist_section_loader.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Load sections into playlist
+    class PlaylistSectionLoader
+      # @param agent [Mechanize]
+      # @param client_id [Integer]
+      # @param owner_id [Integer]
+      # @param playlist_id [Integer]
+      # @param access_hash [String, nil]
+      # @param offset [Integer]
+      # @param up_to [Integer]
+      # @return [Array<Audio>]
+      def self.call(agent, client_id, owner_id, playlist_id, access_hash, offset, up_to)
+        audios = []
+
+        while audios.size < up_to
+          section = Request::PlaylistSection.new(owner_id, playlist_id, access_hash, offset + audios.size, client_id)
+          section.call(agent)
+          audios.concat(section.audios)
+          break if section.audios.empty? || !section.more?
+        end
+
+        audios.first(up_to)
+      end
+    end
+  end
+end

data/lib/vk_music/utility/playlist_url_parser.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Read inner of text-childrens of +Nokogiri::XML::Node+ node
+    class PlaylistUrlParser
+      # Regular expression to parse playlist link. Oh my, it is so big
+      VK_PLAYLIST_URL_POSTFIX = %r{
+        .*                                                              # Garbage
+        (?:audio_playlist|album/|playlist/)                             # Start of ids
+        (-?\d+)_(\d+)                                                   # Ids themself
+        (?:(?:(?:.*(?=&access_hash=)&access_hash=)|/|%2F|_)([\da-z]+))? # Access hash
+      }x.freeze
+      public_constant :VK_PLAYLIST_URL_POSTFIX
+
+      # @param url [String]
+      # @return [Array(Integer?, Integer?, String?)] playlist data array:
+      #   +[owner_id, playlist_id, access_hash]+
+      def self.call(url)
+        owner_id, playlist_id, access_hash = url.match(VK_PLAYLIST_URL_POSTFIX).captures
+
+        owner_id = Integer(owner_id, 10)
+        playlist_id = Integer(playlist_id, 10)
+        access_hash = nil if access_hash&.empty?
+
+        [owner_id, playlist_id, access_hash]
+      rescue StandardError
+        [nil, nil, nil]
+      end
+    end
+  end
+end

data/lib/vk_music/utility/post_loader.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Load wall audios
+    class PostLoader
+      # @param agent [Mechanize]
+      # @param client_id [Integer]
+      # @param owner_id [Integer]
+      # @param post_id [Integer]
+      # @return [Array<Audio>]
+      def self.call(agent, client_id, owner_id, post_id)
+        page = Request::Post.new(owner_id, post_id, client_id)
+        page.call(agent)
+        urlles_audios = page.audios
+
+        wall_audios = WallLoader.call(agent, client_id, owner_id, post_id).audios
+
+        urlles_audios.map { |urlles| wall_audios.find { |audio| audio.like?(urlles) } }.compact
+      end
+    end
+  end
+end

data/lib/vk_music/utility/post_url_parser.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Load wall audios
+    class PostUrlParser
+      # Regex for post URL
+      POST_POSTFIX = /.*wall(-?\d+)_(\d+)/.freeze
+      public_constant :POST_POSTFIX
+
+      # @param url [String]
+      # @return [Array(owner_id?, post_id?)]
+      def self.call(url)
+        matches = url.match(POST_POSTFIX)&.captures
+        return [nil, nil] unless matches && matches.size == 2
+
+        owner_id = Integer(matches[0], 10)
+        post_id = Integer(matches[1], 10)
+
+        [owner_id, post_id]
+      end
+    end
+  end
+end

data/lib/vk_music/utility/profile_id_resolver.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Get user or group id from url
+    class ProfileIdResolver
+      # vk.com url regex
+      VK_PATH = %r{(?:https?://)?(?:vk\.com/)?([^/?&]+)}.freeze
+      public_constant :VK_PATH
+
+      # vk.com user path regex
+      USER_PATH = /id(\d+)/.freeze
+      public_constant :USER_PATH
+
+      # vk.com user club regex
+      CLUB_PATH = /(?:club|group|public|event)(\d+)/.freeze
+      public_constant :CLUB_PATH
+
+      class << self
+        # @param agent [Mechanize]
+        # @param url [String] URL to profile page
+        # @return [Integer?] ID of profile or +nil+ if not a profile page
+        def call(agent, url)
+          path = url.match(VK_PATH)&.captures&.first
+          return unless path
+
+          direct_match = direct_match(path)
+          return direct_match if direct_match
+
+          request = VkMusic::Request::Profile.new(profile_custom_path: path)
+          request.call(agent)
+          request.id
+        rescue Mechanize::ResponseCodeError
+          nil
+        end
+
+        private
+
+        def direct_match(path)
+          user_match = path.match(USER_PATH)
+          return Integer(user_match.captures.first, 10) if user_match
+
+          club_match = path.match(CLUB_PATH)
+          return -1 * Integer(club_match.captures.first, 10) if club_match
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/vk_music/utility/wall_loader.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Load wall audios
+    class WallLoader
+      # @param agent [Mechanize]
+      # @param client_id [Integer]
+      # @param owner_id [Integer]
+      # @param post_id [Integer]
+      # @param up_to [Integer]
+      # @return [Playlist?]
+      def self.call(agent, client_id, owner_id, post_id)
+        page = Request::WallSection.new(owner_id, post_id, client_id)
+        page.call(agent)
+        audios = page.audios
+        return if audios.nil? || audios.empty?
+
+        Playlist.new(audios, id: 0, owner_id: owner_id, access_hash: '',
+                             title: page.title, subtitle: page.subtitle,
+                             real_size: audios.size)
+      end
+    end
+  end
+end

data/lib/vk_music/version.rb

@@ -1,5 +1,8 @@
-module VkMusic
-  ##
-  # Library version.
-  VERSION = "3.1.3"
-end
+# frozen_string_literal: true
+
+module VkMusic
+  # Library version.
+  VERSION = '4.0.0'
+
+  public_constant :VERSION
+end

data/lib/vk_music/web_parser.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module VkMusic
+  # Parses out any data from page received by {Request} objects
+  module WebParser; end
+end
+
+require_relative 'web_parser/base'
+Dir[File.join(__dir__, 'web_parser', '*.rb')].each { |file| require_relative file }

data/lib/vk_music/web_parser/audios.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module WebParser
+    # Audios reload JSON parser
+    class AudiosReload < Base
+      # Array with audio data
+      def audios_data
+        @audios_data ||= json['data'].first || []
+      end
+
+      # @return [Array<Audio>]
+      def audios
+        audios_data.map do |el|
+          Utility::AudioDataParser.call(el, @client_id)
+        end
+      end
+    end
+  end
+end

data/lib/vk_music/web_parser/base.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module WebParser
+    # Base class for all web parsers
+    class Base
+      # @param content [String, Nokogiri::XML::Searchable]
+      # @param client_id [Integer?]
+      def initialize(content, client_id: nil)
+        @content = content
+        @client_id = client_id
+      end
+
+      private
+
+      attr_reader :content
+
+      def node
+        @node ||= @content.is_a?(String) ? Nokogiri::HTML.fragment(@content) : @content
+      end
+
+      def json
+        @json ||= JSON.parse(@content.is_a?(String) ? @content : @content.body)
+      end
+    end
+  end
+end

data/lib/vk_music/web_parser/login.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module WebParser
+    # Login page parser
+    class Login < Base
+      # @return [Mechanize::Form]
+      def login_form
+        node.forms.find { |f| f.action.start_with?('https://login.vk.com') }
+      end
+    end
+  end
+end

data/lib/vk_music/web_parser/my_page.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module WebParser
+    # Current user page parser
+    class MyPage < Base
+      # User id
+      def id
+        Integer(node.content.match(/window.vk = {"id":(\d+)/).captures.first, 10)
+      end
+
+      # User name
+      def name
+        link = node.at_css('.ip_user_link .op_owner')
+        link.attribute('data-name').value
+      end
+    end
+  end
+end

data/lib/vk_music/web_parser/playlist.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module WebParser
+    # Playlist mobile web page parser
+    class Playlist < Base
+      # @return [Array<Audio>]
+      def audios
+        Utility::AudioItemsParser.call(node, @client_id)
+      end
+
+      # @return [String]
+      def title
+        node.at_css('.audioPlaylist__title').content.strip
+      end
+
+      # @return [String?]
+      def subtitle
+        result = node.at_css('.audioPlaylist__subtitle').content.strip
+        return if result.nil? || result.empty?
+
+        result
+      end
+
+      # @return [Integer?]
+      def real_size
+        content = node.at_css('.audioPlaylist__footer').content
+        matches = content.gsub(/\s/, '').match(/^(\d+)/)&.captures
+        matches ? Integer(matches.first, 10) : nil
+      end
+    end
+  end
+end

data/lib/vk_music/web_parser/playlist_section.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module WebParser
+    # PlaylistSection JSON parser
+    class PlaylistSection < Base
+      # Parsed JSON
+      def data
+        @data ||= json['data'].first || {}
+      end
+
+      # @return [Array<Audio>]
+      def audios
+        return unless data&.key?('list')
+
+        data['list'].map do |el|
+          Utility::AudioDataParser.call(el, @client_id)
+        end
+      end
+
+      # @return [String]
+      def title
+        return unless data&.key?('title')
+
+        data['title'].to_s
+      end
+
+      # @return [String?]
+      def subtitle
+        return unless data&.key?('rawDescription')
+
+        re = data['rawDescription']
+        return if re.nil? || re.empty?
+
+        re
+      end
+
+      # @return [Integer?]
+      def real_size
+        return unless data&.key?('totalCount')
+
+        data['totalCount']
+      end
+
+      # @return [Boolean]
+      def more?
+        return unless data&.key?('hasMore')
+
+        data['hasMore'].to_s == '1'
+      end
+    end
+  end
+end