vk_music 3.1.7 → 4.1.0

data/lib/vk_music/utility/duration_parser.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Turn human readable track length to its size in seconds
+    module DurationParser
+      # @param str [String] string in format "HH:MM:SS" or something alike (+/d++ Regex selector is used)
+      # @return [Integer] amount of seconds
+      def self.call(str)
+        str.scan(/\d+/)
+           .map(&:to_i)
+           .reverse
+           .each_with_index.reduce(0) { |acc, (count, position)| acc + count * 60**position }
+      end
+    end
+  end
+end

data/lib/vk_music/utility/last_profile_post_loader.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'profile_id_resolver'
+
+module VkMusic
+  module Utility
+    # Get user or group id from url
+    module LastProfilePostLoader
+      # vk.com url regex
+      VK_PATH = ProfileIdResolver::VK_PATH
+      private_constant :VK_PATH
+
+      # @param agent [Mechanize]
+      # @param url [String] URL to profile page
+      # @return [Array(owner_id?, post_id?)]
+      def self.call(agent, url: nil, owner_id: nil)
+        path = url&.match(VK_PATH)&.captures&.first
+        request = VkMusic::Request::Profile.new(profile_id: owner_id, profile_custom_path: path)
+        request.call(agent)
+        [request.id, request.last_post_id]
+      rescue Mechanize::ResponseCodeError
+        [nil, nil]
+      end
+    end
+  end
+end

data/lib/vk_music/utility/link_decoder.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Link decoding utilities
+    module LinkDecoder
+      # JS code which creates function to unmask audio URL.
+      JS_CODE = <<~HEREDOC
+        function vk_unmask_link(link, vk_id) {
+
+          // Utility functions to unmask
+
+          var audioUnmaskSource = function (encrypted) {
+            if (encrypted.indexOf('audio_api_unavailable') != -1) {
+              var parts = encrypted.split('?extra=')[1].split('#');
+
+              var handled_anchor = '' === parts[1] ? '' : handler(parts[1]);
+
+              var handled_part = handler(parts[0]);
+
+              if (typeof handled_anchor != 'string' || !handled_part) {
+                // if (typeof handled_anchor != 'string') console.warn('Handled_anchor type: ' + typeof handled_anchor);
+                // if (!handled_part) console.warn('Handled_part: ' + handled_part);
+                return encrypted;
+              }
+
+              handled_anchor = handled_anchor ? handled_anchor.split(String.fromCharCode(9)) : [];
+
+              for (var func_key, splited_anchor, l = handled_anchor.length; l--;) {
+                splited_anchor = handled_anchor[l].split(String.fromCharCode(11));
+                func_key = splited_anchor.splice(0, 1, handled_part)[0];
+                if (!utility_object[func_key]) {
+                  // console.warn('Was unable to find key: ' + func_key);
+                  return encrypted;
+                }
+                handled_part = utility_object[func_key].apply(null, splited_anchor)
+              }
+
+              if (handled_part && 'http' === handled_part.substr(0, 4)) return handled_part;
+              // else console.warn('Failed unmasking: ' + handled_part);
+            } else {
+              // console.warn('Bad link: ' + encrypted);
+            }
+            return encrypted;
+          }
+
+          var handler = function (part) {
+            if (!part || part.length % 4 == 1) return !1;
+            for (var t, i, o = 0, s = 0, a = ''; i = part.charAt(s++);) {
+              i = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN0PQRSTUVWXYZO123456789+/='.indexOf(i)
+              ~i && (t = o % 4 ? 64 * t + i : i, o++ % 4) && (a += String.fromCharCode(255 & t >> (-2 * o & 6)));
+            }
+            return a;
+          }
+
+          var utility_object = {
+            i: function(e, t) {
+              return utility_object.s(e, t ^ vk_id);
+            },
+            s: function(e, t) {
+              var n = e.length;
+              if (n) {
+                var i = r_func(e, t),
+                  o = 0;
+                for (e = e.split(''); ++o < n;)
+                  e[o] = e.splice(i[n - 1 - o], 1, e[o])[0];
+                e = e.join('')
+              }
+              return e;
+            }
+          };
+
+          var r_func = function (e, t) {
+            var n = e.length,
+              i = [];
+            if (n) {
+              var o = n;
+              for (t = Math.abs(t); o--;)
+                t = (n * (o + 1) ^ t + o) % n,
+                i[o] = t;
+            }
+            return i;
+          }
+
+          return audioUnmaskSource(link);
+        }
+      HEREDOC
+      private_constant :JS_CODE
+
+      # JS context with unmasking link
+      @@js_context = ExecJS.compile(JS_CODE)
+
+      # Unmask audio download URL
+      # @param link [String] encoded link to audio. Usually looks like
+      #   "https://m.vk.com/mp3/audio_api_unavailable.mp3?extra=...".
+      # @param client_id [Integer] ID of user which got this link. ID is required for decoding.
+      # @return [String?] audio download URL, which can be used only from current IP.
+      def self.call(link, client_id)
+        VkMusic.log.debug('LinkDecoder') { "Unmasking link `#{link}` with client id #{client_id}" }
+        @@js_context.call('vk_unmask_link', link, client_id)
+      rescue StandardError => e
+        VkMusic.log.warn('LinkDecoder') { "Failed to decode link `#{link}`: #{e.full_message}" }
+        nil
+      end
+    end
+  end
+end

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
+    module 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
+    module 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
+    module 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
+    module 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
+    module 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
+    module 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
+    module 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,58 @@
+# frozen_string_literal: true
+
+module VkMusic
+  module Utility
+    # Get user or group id from url
+    module ProfileIdResolver
+      # vk.com url regex
+      VK_PATH = %r{(?:https?://)?(?:vk\.com/)?([^/?&]+)}.freeze
+      public_constant :VK_PATH
+
+      # audios list page
+      AUDIOS_PATH = /audios(-?\d+)/.freeze
+      public_constant :AUDIOS_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)
+          audios_match = path.match(AUDIOS_PATH)
+          return Integer(audios_match.captures.first, 10) if audios_match
+
+          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
+    module 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,7 @@
-module VkMusic
-  ##
-  # Library version.
-  VERSION = "3.1.7"
-end
+# frozen_string_literal: true
+
+module VkMusic
+  # Library version.
+  VERSION = '4.1.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 }