vk_music 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 63b8f9761d95697dd5ee579716fe92afdf11b8a1dfed9e1ec4549190149df0ef
+  data.tar.gz: 6c061d1b1c76e1012312a076cd286d56ba330e96746d7eef5d05b62b84301773
+SHA512:
+  metadata.gz: 5f5dc98d3e2442de549c547a983cdbedb01a3638a2381d8eaaacb20c9453b711ebf684f284991e000387908310410fd897649c47fed7d6ec1dbb61477d139771
+  data.tar.gz: cac49dbd426c6825d615f5566c7eb94ee086df721366b626b6bb13a5faed7fdadb56087793f5ffb2f278f6d940502ff8de0244532544099196e0e7227c7ed1ba

data/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Kuznecov Vladislav
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,6 @@
+desc "Build gem file"
+task :build do
+  `gem build vk_music.gemfile`
+end
+
+# TODO: Test task

data/lib/vk_music.rb

@@ -0,0 +1,7 @@
+require_relative 'vk_music/utility.rb'
+require_relative 'vk_music/constants.rb'
+require_relative 'vk_music/exceptions.rb'
+require_relative 'vk_music/audio.rb'
+require_relative 'vk_music/link_decoder.rb'
+require_relative 'vk_music/playlist.rb'
+require_relative 'vk_music/client.rb'

data/lib/vk_music/audio.rb

@@ -0,0 +1,46 @@
+module VkMusic
+
+  class Audio
+  
+    attr_reader :id, :owner_id, :artist, :title, :duration, :url, :url_encoded
+    
+    def to_s
+      "#{@artist} - #{@title} [#{Utility.format_seconds(@duration)}]"
+    end
+  
+    def initialize(options)
+      # Arguments check
+      raise ArgumentError, "options hash must be provided", caller unless options.class == Hash
+      raise ArgumentError, "artist is not provided", caller unless options.has_key?(:artist)
+      raise ArgumentError, "title is not provided", caller unless options.has_key?(:title)
+      raise ArgumentError, "duration is not provided", caller unless options.has_key?(:duration)
+      
+      # Setting up attributes
+      @id          = options[:id].to_s
+      @owner_id    = options[:owner_id].to_s
+      @artist      = options[:artist].to_s
+      @title       = options[:title].to_s
+      @duration    = options[:duration].to_i
+      @url_encoded = options[:url_encoded].to_s
+      @url         = options[:url].to_s
+    end
+    
+    def self.from_node(node, client_id)
+      url_encoded = node.at_css("input").attribute("value").to_s
+      url_encoded = nil if url_encoded == "https://m.vk.com/mp3/audio_api_unavailable.mp3"
+      id_array = node.attribute("data-id").to_s.split("_")
+      
+      new({
+        :id => id_array[1],
+        :owner_id => id_array[0],
+        :artist => node.at_css(".ai_artist").text.strip,
+        :title => node.at_css(".ai_title").text.strip,
+        :duration => node.at_css(".ai_dur").attribute("data-dur").to_s.to_i,
+        :url_encoded => url_encoded,
+        :url => url_encoded ? VkMusic.unmask_link(url_encoded, client_id) : "",
+      })
+    end
+  
+  end
+  
+end

data/lib/vk_music/client.rb

@@ -0,0 +1,113 @@
+require "mechanize"
+
+module VkMusic
+
+  class Client
+  
+    attr_reader :id, :name
+    
+    # Mechanize agent
+    @agent = nil
+  
+    def initialize(options)
+      # Arguments check
+      raise ArgumentError, "options hash must be provided", caller unless options.class == Hash
+      raise ArgumentError, "username is not provided", caller unless options.has_key?(:username)
+      raise ArgumentError, "password is not provided", caller unless options.has_key?(:password)
+      
+      # Setting up client
+      @agent = Mechanize.new
+      login(options[:username], options[:password])
+    end
+    
+    def find_audio(query)
+      uri = URI(VK_URL[:audios])
+      uri.query = URI.encode_www_form("act" => "search", "q" => query.to_s)
+      load_audios_from(uri)
+    end
+    
+    def get_playlist(url, up_to = nil)
+      url, owner_id, id, access_hash = url.match(PLAYLIST_URL_REGEX).to_a
+
+      # Load first page and get info
+      first_page = load_playlist_page(owner_id: owner_id, id: id, access_hash: access_hash, offset: 0)
+      title = first_page.at_css(".audioPlaylist__title").text.strip
+      subtitle = first_page.at_css(".audioPlaylist__subtitle").text.strip
+      
+      footer_node = first_page.at_css(".audioPlaylist__footer")
+      if footer_node
+        footer_match = footer_node.text.strip.match(/^\d+/)
+        playlist_size = footer_match ? footer_match[0].to_i : 0
+      else
+        playlist_size = 0
+      end
+      
+      first_page_audios = load_audios_from(first_page)
+      
+      # Check whether need to make additional requests
+      up_to = playlist_size if (up_to.nil? || up_to < 0 || up_to > playlist_size)
+      if first_page_audios.length >= up_to
+        list = first_page_audios[0, up_to]
+      else        
+        list = first_page_audios
+        loop do
+          playlist_page = load_playlist_page(owner_id: owner_id, id: id, access_hash: access_hash, offset: list.length)
+          list.concat(load_audios_from(playlist_page)[0, up_to - list.length])
+          break if list.length == up_to
+        end        
+      end
+      
+      Playlist.new(list, {
+        :id => id,
+        :owner_id => owner_id,
+        :access_hash => access_hash,
+        :title => title,
+        :subtitle => subtitle,
+      })
+    end
+    
+    private
+    # Loading pages
+    def load_page(url)
+      uri = URI(url) if url.class != URI      
+      @agent.get(uri)
+    end
+    def load_playlist_page(options)
+      uri = URI(VK_URL[:audios])
+      uri.query = URI.encode_www_form("act" => "audio_playlist#{options[:owner_id]}_#{options[:id]}", "access_hash" => options[:access_hash].to_s, "offset" => options[:offset].to_i)
+      load_page(uri)
+    end
+    
+    
+    # Loading audios
+    def load_audios_from(obj)
+      page = obj.class == Mechanize::Page ? obj : load_page(obj)
+      page.css(".audio_item.ai_has_btn").map { |elem| Audio.from_node(elem, @id) }
+    end 
+    
+    
+    def login(username, password)
+      # Loading login page
+      homepage = load_page(VK_URL[:home])
+      # Submitting login form
+      login_form = homepage.forms.find { |form| form.action.start_with?(VK_URL[:login_action]) }
+      login_form[VK_LOGIN_FORM_NAMES[:username]] = username.to_s
+      login_form[VK_LOGIN_FORM_NAMES[:password]] = password.to_s
+      after_login = @agent.submit(login_form)
+
+      # Checking whether logged in
+      raise LoginError, "unable to login. Redirected to #{after_login.uri.to_s}", caller unless after_login.uri.to_s == VK_URL[:feed]
+      
+      # Parsing information about this profile
+      profile = load_page(VK_URL[:profile])      
+      @name = profile.title
+      @id = profile.link_with(href: /audios/).href.slice(/\d+/)
+    end
+    
+    def unmask_link(link)
+      VkMusic.unmask_link(link, @id)
+    end
+    
+  end
+  
+end

data/lib/vk_music/constants.rb

@@ -0,0 +1,28 @@
+module VkMusic
+
+  # Web
+  # DEFAULT_USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1636.0 Safari/537.36"
+
+  VK_URL = {
+    :scheme => "https",
+    :host => "m.vk.com",
+    :home => "https://m.vk.com",
+    :profile => "https://m.vk.com/id0",
+    :feed => "https://m.vk.com/feed",
+    :audios => "https://m.vk.com/audio",
+    :login  => "https://m.vk.com/login",
+    :login_action => "https://login.vk.com",
+  }
+  
+  VK_LOGIN_FORM_NAMES = {
+    :username => "email",
+    :password => "pass",
+  }
+  
+  # Playlist
+  PLAYLIST_URL_REGEX = /.*audio_playlist(-?[\d]+)_([\d]+)(?:(?:(?:&access_hash=)|\/|%2F)([\da-z]+))?/
+  
+  
+  # QUESTION: Should I move ALL the constants (string, regex etc) here? It would make code more flexible, but seems like overkill
+  
+end

data/lib/vk_music/exceptions.rb

@@ -0,0 +1,7 @@
+module VkMusic
+
+  class LoginError < RuntimeError
+    # Unable to login
+  end
+  
+end

data/lib/vk_music/link_decoder.rb

@@ -0,0 +1,94 @@
+require "duktape"
+
+module VkMusic
+
+  # Setting up decoding context
+  @@js_context = Duktape::Context.new
+  js_code = <<END_OF_STRING
+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);
+}
+END_OF_STRING
+  @@js_context.exec_string js_code
+  
+
+  def self.unmask_link(link, client_id)
+    @@js_context.call_prop("vk_unmask_link", link.to_s, client_id.to_i)  
+  end
+  
+end

data/lib/vk_music/playlist.rb

@@ -0,0 +1,42 @@
+module VkMusic
+
+  class Playlist
+    include Enumerable
+    
+    attr_reader :id, :owner_id, :access_hash, :title, :subtitle
+    
+    def length
+      @list.length
+    end
+    alias size length
+    
+    def to_s
+      "#{@subtitle} - #{@title} (#{self.length} аудиозаписей)"
+    end
+    
+    def each(&block)
+      @list.each(&block)
+    end
+    
+    def [](index)
+      @list[index]
+    end
+  
+    def initialize(list, options = {})
+      # Arguments check
+      raise ArgumentError, "array of audios must be provided", caller unless list.class == Array
+      
+      # Saving list
+      @list = list.dup
+      
+      # Setting up attributes
+      @id          = options[:id].to_s
+      @owner_id    = options[:owner_id].to_s
+      @access_hash = options[:access_hash].to_s
+      @title       = options[:title].to_s
+      @subtitle    = options[:subtitle].to_s
+    end
+  
+  end
+  
+end

data/lib/vk_music/utility.rb

@@ -0,0 +1,12 @@
+module VkMusic
+
+  module Utility
+  
+    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
+    
+  end
+  
+end

data/test/test_login.rb

@@ -0,0 +1,12 @@
+require "minitest/autorun"
+require_relative "../lib/vk_music.rb"
+
+class Example < MiniTest::Test
+  def test_bad_data
+    assert_raises(VkMusic::LoginError) {
+      client = VkMusic::Client.new(username: "login", password: "password")
+    }
+  end
+  
+  # TODO: any way to test correct login?
+end

data/vk_music.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name           = "vk_music"
+  s.summary        = "Provides interface to work with VK music via HTTP requests"
+  s.version        = "0.0.1"
+  s.author         = "Kuznecov Vladislav"
+  s.email          = "fizvlad@mail.ru"
+  s.homepage       = "https://github.com/fizvlad/vk-music-rb"
+  s.platform       = Gem::Platform::RUBY
+  s.required_ruby_version = ">=2.5.1"
+  s.files          = Dir[ "lib/**/**", "test/**/**", "LICENSE", "Rakefile", "README", "vk_music.gemspec" ]
+  s.test_files     = Dir[ "test/test*.rb" ]
+  s.has_rdoc       = false
+  s.license        = "MIT"
+  
+  s.add_runtime_dependency "mechanize", "~>2.7"
+  s.add_runtime_dependency "duktape",   "~>2.3"
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: vk_music
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kuznecov Vladislav
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-06-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mechanize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: duktape
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+description: 
+email: fizvlad@mail.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- Rakefile
+- lib/vk_music.rb
+- lib/vk_music/audio.rb
+- lib/vk_music/client.rb
+- lib/vk_music/constants.rb
+- lib/vk_music/exceptions.rb
+- lib/vk_music/link_decoder.rb
+- lib/vk_music/playlist.rb
+- lib/vk_music/utility.rb
+- test/test_login.rb
+- vk_music.gemspec
+homepage: https://github.com/fizvlad/vk-music-rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Provides interface to work with VK music via HTTP requests
+test_files:
+- test/test_login.rb