vk_music 1.1.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c6e2d05ccf44bc32534cc66a85c2495f799e247876495df962bd312b3cef644
-  data.tar.gz: acc2fab3d0f196536f195cecea4f5bd0c997a6e14566a9a8a574b444db98bf4e
+  metadata.gz: e42dd22de66cd8bb8d2d0b70686102d4d50078677736b036b7c383470ff31f2a
+  data.tar.gz: c6d3eb20221b599d48a1e4464b837ef294d926b4bc9fbeb81b348e9ae5c63f90
 SHA512:
-  metadata.gz: 9f31a0049dc14a0ef0603f503733593a5bd8ffc2a26cae4ce4c6bb4ace98d175f86745ead97e2293d9157a2bf62b323c2f61254c01940b37505715c35454fdbc
-  data.tar.gz: 20fa21e9ee919f544664c20c149089ce594967bafa9809e7ab28ed68f53ab68d0147f5451fac66d83fe4453d1e3c388614fc543958f024d911ff24439cf94bb5
+  metadata.gz: 515fbb7b67a8a53b0e2bc8ed0ef8f34a4cdda560ad94a4880ff8e9b36fb7d3c023386b6c2fca3d0df59eb19487d5a708d21684ddb3bf25bcbda4b2141506dd63
+  data.tar.gz: 40eac37ca4af3db6eb0d88a7e93277f923565c013207706e0d29e7b14a18354628d9bdb79b8eb71de753571a29a4ed93bbeb0e3adad697a4cdc6cfed3c9598a0

data/README.md

@@ -29,6 +29,8 @@ gem install vk_music-*.gem
 
 ## Usage
 
+You can take a look on documentation [here](https://www.rubydoc.info/gems/vk_music/).
+
 ### Logging in
 Firstly, it is required to create new *VkMusic::Client* and provide login credentials:
 ```ruby
@@ -38,7 +40,7 @@ client = VkMusic::Client.new(username: "+71234567890", password: "password")
 ### Searching for audios
 You can search audios by name with following method:
 ```ruby
-audios = client.find_audio("Acid Spit - Mega Drive")
+audios = client.find("Acid Spit - Mega Drive")
 puts audios[0]     # Basic information about audio
 puts audios[0].url # URL to access audio. Notice that it is only accessible from your IP
 ```
@@ -46,28 +48,28 @@ puts audios[0].url # URL to access audio. Notice that it is only accessible from
 ### Parsing playlists
 You can load all the audios from playlist using following method:
 ```ruby
-playlist = client.get_playlist("https://vk.com/audio?z=audio_playlist-37661843_1/0e420c32c8b69e6637")
+playlist = client.playlist("https://vk.com/audio?z=audio_playlist-37661843_1/0e420c32c8b69e6637")
 ```
 It is only possible to load up to 100 audios from playlist per request, so you can reduce amount of requests by setting up how many audios from playlist you actually need.
 For example, following method will perform only one HTML request:
 ```ruby
-playlist = client.get_playlist("https://vk.com/audio?z=audio_playlist121570739_7", 100)
+playlist = client.playlist("https://vk.com/audio?z=audio_playlist121570739_7", up_to: 100)
 urls = playlist.map(&:url) # URLs for every audio
 ```
 
 ### User or group audios
 You can load first 100 audios from user or group page. Those audios will be returned as playlist. To do it simply pass user or group id:
 ```ruby
-user_playlist = client.get_audios("8024985")
-group_playlist = client.get_audios("-4790861") # Group and public id starts with '-'
+user_playlist = client.audios(owner_id: 8024985)
+group_playlist = client.audios(owner_id: -4790861) # Group and public id starts with '-'
 ```
 You can set how many audios you actually need as well:
 ```ruby
-user_playlist = client.get_audios("8024985", 10)
+user_playlist = client.audios(owner_id: 8024985, up_to: 10)
 ```
 
 ### Audios from post
 You can load up to 10 audios attached to some post. Those audios will be returned as array:
 ```ruby
-audios = client.get_audios_from_post("https://vk.com/wall-4790861_5453")
+audios = client.post("https://vk.com/wall-4790861_5453")
 ```

data/Rakefile

@@ -1,3 +1,8 @@
+desc "Create documentation"
+task :doc do
+  puts `yardoc`
+end
+
 desc "Build gem file"
 task :build do
   puts `gem build vk_music.gemspec`

data/lib/vk_music.rb

@@ -1,7 +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/utility.rb"
 require_relative "vk_music/link_decoder.rb"
+require_relative "vk_music/audio.rb"
 require_relative "vk_music/playlist.rb"
-require_relative "vk_music/client.rb"
+require_relative "vk_music/client.rb"

data/lib/vk_music/audio.rb

@@ -1,138 +1,202 @@
 require "cgi"
 
+##
+# @!macro [new] options_hash_param
+#   @param options [Hash] hash with options.
+
 module VkMusic
 
-  # VK audio.
+  ##
+  # Class representing VK audio.
   class Audio
   
-    # Id of audio.
+    ##
+    # @return [Integer, nil] ID of audio.
     attr_reader :id
-    # Id of audio owner.
+
+    ##
+    # @return [Integer, nil] ID of audio owner.
     attr_reader :owner_id
-    # Parts of secret hash which used when using +act=reload_audio+
+    
+    ##
+    # @return [String, nil] part of secret hash which used when using +act=reload_audio+.
     attr_reader :secret_1, :secret_2
-    # Artist.
+    
+    ##
+    # @return [String] name of artist.
     attr_reader :artist
-    # Title.
+    
+    ##
+    # @return [String] title of song.
     attr_reader :title
-    # Duration.
+
+    ##
+    # @return [Integer] duration of track in seconds.
     attr_reader :duration
-    # Download URL.
-    attr_reader :url
-    # Encoded URL.
-    attr_reader :url_encoded
 
-    # Update audio URLs.
+    ##
+    # Access decoded download URL.
     #
-    # If +:url+ is provided - just save it.
-    # If +:url_encoded+ and +:client_id+ provided - unmask link first.
+    # If link was already decoded, returns cached value. Else decodes existing link.
+    # If no link can be provided, returns +nil+.
     #
-    # ===== Parameters:
-    # * [+options+] (+Hash+)
-    #
-    # ===== Options:
-    # * +:url+
-    # * +:url_encoded+
-    # * +:client_id+
-    def update_url(options)
-      raise ArgumentError, "options hash must be provided", caller unless options.class == Hash
-      if !options[:url].to_s.empty?
-        @url_encoded = ""
-        @url = options[:url].to_s
-      elsif !options[:url].to_s.empty? && options[:client_id]
-        @url_encoded = options[:url_encoded].to_s
-        @url = VkMusic::LinkDecoder.unmask_link(options[:url_encoded], options[:client_id])
+    # @return [String, nil] decoded download URL or +nil+ if not available.
+    def url
+      if url_cached?
+        @url
+      elsif @url_encoded && @client_id
+        @url = VkMusic::LinkDecoder.unmask_link(@url_encoded, @client_id)
       else
-        raise ArgumentError, "You should either provide :url or :url_encoded and :client_id", caller
+        @url # nil
       end
     end
+
+    ##
+    # @return [String, nil] encoded download URL.
+    attr_reader :url_encoded
+
+    ##
+    # @return [Boolean] whether decoded URL is already cached.
+    def url_cached?
+      !!(@url)
+    end
+
+    ##
+    # @return [Boolean] whether able to get download URL without web requests.
+    def url_available?
+      !!(url_cached? || (@url_encoded && @client_id))
+    end
+
+    ##
+    # @return [Boolean] whether it's possible to get download URL with {Client#from_id}.
+    def url_accessable?
+      !!(@id && @owner_id && @secret_1 && @secret_2)
+    end
     
-    # Returns string with information about audio.
+    ##
+    # @return [String] information about audio.
     def to_s
       "#{@artist} - #{@title} [#{Utility.format_seconds(@duration)}]"
     end
 
-    # Returns extended information about audio.
+    ##
+    # @return [String] extended information about audio.
     def pp
-      "#{to_s} (Got decoded URL: #{@url ? "yes" : "no"}, able to get URL from VK: #{@id && @owner_id && @secret_1 && @secret_2 ? "yes" : "no"})"
+      "#{to_s} (Able to get decoded URL: #{url_available? ? "yes" : "no"}, able to get URL from VK: #{url_accessable? ? "yes" : "no"})"
+    end
+
+    ##
+    # Update audio URLs.
+    #
+    # @overload update_url(decoded_url)
+    #   Simply save download URL.
+    #   @param decoded_url [String]
+    #
+    # @overload update_url(audio)
+    #   Copy URLs from this audio (no checks applied).
+    #   @param audio [Audio]
+    #
+    # @overload update_url(options)
+    #   @macro options_hash_param
+    #   @option options [String, nil] :url decoded download URL.
+    #   @option options [String, nil] :url_encoded decoded download URL.
+    #   @option options [String, nil] :client_id decoded download URL.
+    #
+    # @return [self]
+    def update_url(arg)
+      case arg
+        when String
+          @url = arg
+        when Audio
+          # Only save URL if it's already decoded and cached
+          @url = arg.url if arg.url_cached?
+          @url_encoded = arg.url_encoded
+          @client_id = arg.client_id
+        when Hash
+          @url_encoded = Utility.unless_nil_to String, options[:url_encoded]
+          @url         = Utility.unless_nil_to String, options[:url]
+          @client_id   = Utility.unless_nil_to Integer, options[:client_id]
+        else
+          raise ArgumentError, "Bad arguments", caller
+      end
+      self
     end
   
+    ##
     # Initialize new audio.
     #
-    # ===== Parameters:
-    # * [+options+] (+Hash+)
+    # @macro options_hash_param
     #
-    # ===== Options:
-    # * +:id+
-    # * +:owner_id+
-    # * +:secret_1+
-    # * +:secret_2+
-    # * +:artist+
-    # * +:title+
-    # * +:duration+
-    # * +:url_encoded+
-    # * +:url+
-    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
-      @secret_1    = options[:secret_1].to_s
-      @secret_2    = options[:secret_2].to_s
+    # @option options [Integer, nil] :id
+    # @option options [Integer, nil] :owner_id
+    # @option options [String, nil] :secret_1
+    # @option options [String, nil] :secret_2
+    # @option options [String] :artist
+    # @option options [String] :title
+    # @option options [Integer] :duration
+    # @option options [String, nil] :url_encoded
+    # @option options [String, nil] :url
+    # @option options [Integer, nil] :client_id
+    def initialize(options = {})
+      @id          = Utility.unless_nil_to Integer, options[:id]
+      @owner_id    = Utility.unless_nil_to Integer, options[:owner_id]
+      @secret_1    = Utility.unless_nil_to String, options[:secret_1]
+      @secret_2    = Utility.unless_nil_to String, options[:secret_2]
       @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
+      @url_encoded = Utility.unless_nil_to String, options[:url_encoded]
+      @url         = Utility.unless_nil_to String, options[:url]
+      @client_id   = Utility.unless_nil_to Integer, options[:client_id]
     end
     
+    ##
     # Initialize new audio from Nokogiri HTML node.
     #
-    # ===== Parameters:
-    # * [+node+] (+Nokogiri::XML::Node+)
-    # * [+client_id+] (+Integer+)
+    # @param node [Nokogiri::XML::Node] node, which match following CSS selector: +.audio_item.ai_has_btn+
+    # @param client_id [Integer]
+    #
+    # @return [Audio]
     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"
+      url_encoded = nil if url_encoded == Constants::URL::VK[:audio_unavailable]
       id_array = node.attribute("data-id").to_s.split("_")
       
       new({
-        :id => id_array[1],
-        :owner_id => id_array[0],
+        :id => id_array[1].to_i,
+        :owner_id => id_array[0].to_i,
         :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::LinkDecoder.unmask_link(url_encoded, client_id) : nil,
+        :url_encoded => url_encoded.to_s,
+        :url => nil,
+        :client_id => client_id
       })
     end
     
-    # Initialize new audio from data array.
+    ##
+    # Initialize new audio from VK data array.
+    #
+    # @param data [Array]
+    # @param client_id [Integer]
     #
-    # ===== Parameters:
-    # * [+data+] (+Array+)
-    # * [+client_id+] (+Integer+)
-    def self.from_data_array(data, client_id)
-      url_encoded = data[2]
-      url_encoded = nil if url_encoded == ""
+    # @return [Audio]
+    def self.from_data(data, client_id)
+      url_encoded = data[2].to_s
       
-      secrets = data[13].split("/")
+      secrets = data[13].to_s.split("/")
 
       new({
-        :id => data[0],
-        :owner_id => data[1],
+        :id => data[0].to_i,
+        :owner_id => data[1].to_i,
         :secret_1 => secrets[3],
         :secret_2 => secrets[5],
         :artist => CGI.unescapeHTML(data[4]),
         :title => CGI.unescapeHTML(data[3]),
-        :duration => data[5],
+        :duration => data[5].to_i,
         :url_encoded => url_encoded,
-        :url => url_encoded ? VkMusic::LinkDecoder.unmask_link(url_encoded, client_id) : nil,
+        :url => nil,
+        :client_id => client_id
       })
     end
   

data/lib/vk_music/client.rb

@@ -1,334 +1,525 @@
 require "mechanize"
 require "json"
 
+##
+# @!macro [new] options_hash_param
+#   @param options [Hash] hash with options.
+#
+# @!macro [new] playlist_return
+#   @return [Playlist] playlist with audios. Possibly empty.
+#     Possibly contains audios without download URL.
+
+##
+# Main module.
 module VkMusic
 
+  ##
   # Main class with all the interface.
+  # To start working with VK audios firstly create new client with +Client.new+.
   class Client
   
-    # ID of user
+    ##
+    # @return [Integer] ID of client.
     attr_reader :id
-    # Name of user
+
+    ##
+    # @return [String] name of client.
     attr_reader :name
     
-    # Mechanize agent
-    @agent = nil
-  
-    def initialize(options)
+    @agent = nil # Mechanize agent
+
+    ##
+    # Create new client and login.
+    #
+    # @macro options_hash_param
+    #
+    # @option options [String] :username usually telephone number or email.
+    # @option options [String] :password
+    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)
+      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
+
+    ##
+    #@!group Loading audios
     
-    # Find Audio.
+    ##
+    # Search for audio.
+    #
+    # @note some audios might be removed from search.
     #
-    # ===== Parameters:
-    # * [+query+] (+String+) - string to search for.
+    # @todo search in group audios.
     #
-    # ===== Returns:
-    # * (+Array+) - array of Audio.
-    def find_audio(query)
-      uri = URI(Constants::VK_URL[:audios])
+    # @overload find(query)
+    #   @param query [String] string to search for.
+    #
+    # @overload find(options)
+    #   @macro options_hash_param
+    #   @option options [String] :query string to search for.
+    #
+    # @return [Array<Audio>] array with audios matching given string. Possibly empty.
+    #   Possibly contains audios without download URL.
+    def find(arg)
+      begin
+        case arg
+          when String
+            query = arg
+          when Hash
+            query = arg[:query].to_s
+          else
+            raise
+        end
+      rescue
+        raise ArgumentError, "Bad arguments", caller
+      end
+
+      uri = URI(Constants::URL::VK[:audios])
       uri.query = Utility.hash_to_params({ "act" => "search", "q" => query.to_s })
-      load_audios_from_page(uri)
+
+      audios__from_page(uri)
     end
+    alias search find
     
-    # Get Playlist.
+    ##
+    # @!macro [new] pl__options
+    #   @option options [Integer] :up_to (MAXIMUM_PLAYLIST_SIZE) maximum amount of audios to load.
+    #     If 0, no audios would be loaded (Just information about playlist).
+    #     If less than 0, will load whole playlist.
+    #   @option options [Boolean] :with_url (true) makes all the audios have download URLs,
+    #     but every 100 audios will cost one more request. You can reduce amount of requests using option +up_to+.
+    #     Otherwise audio download URL would be accessable only with {Client#from_id}.
+    #     Main advantage of disabling URLs is the fact that 2000 audios will be loaded per request,
+    #     which is 20 times more effecient.
+    #
+    # Get VK playlist.
     #
-    # ===== Parameters:
-    # * [+url+] (+String+) - url to playlist.
-    # * [+up_to+] (+Integer+) - maximum amount of Audio to load.
+    # @overload playlist(url, options)
+    #   @param url [String] URL to playlist.
+    #   @macro options_hash_param
+    #   @macro pl__options
     #
-    # ===== Returns:
-    # * (+Playlist+)
-    def get_playlist(url, up_to = nil)
-      # NOTICE: it is possible to use same type of requests as in get_audios method
+    # @overload playlist(options)
+    #   Use options +owner_id+, +playlist_id+ and +access_hash+ instead of URL.
+    #   @macro options_hash_param
+    #   @option options [Integer] :owner_id playlist owner ID.
+    #   @option options [Integer] :playlist_id ID of the playlist.
+    #   @option options [String] :access_hash access hash to playlist. Might not exist.
+    #   @macro pl__options
+    #
+    # @macro playlist_return 
+    def playlist(*args)
       begin
-        url, owner_id, id, access_hash = url.to_s.match(Constants::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)
-        
-        # Parse out essential data
-        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
+        case
+          when (args.size == 1 && String === args[0]) ||
+               (args.size == 2 && String === args[0] && Hash === args[1])
+            options = args[1] || {}
+            owner_id, playlist_id, access_hash = args[0].to_s.match(Constants::Regex::VK_PLAYLIST_URL_POSTFIX).captures
+          when args.size == 1 && Hash === args[0]
+            options = args[0]
+            owner_id, playlist_id, access_hash = options[:owner_id].to_i, options[:playlist_id].to_i, options[:access_hash].to_s
+          else
+            raise
         end
-      rescue Exception => error
-        raise Exceptions::PlaylistParseError, "unable to parse playlist page. Error: #{error.message}", caller
+      rescue
+        raise ArgumentError, "Bad arguments", caller
       end
-      # Now we can be sure we are on correct page
-      
-      first_page_audios = load_audios_from_page(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_page(playlist_page)[0, up_to - list.length])
-          break if list.length == up_to
-        end        
+      options[:up_to]    ||= Constants::MAXIMUM_PLAYLIST_SIZE
+      options[:with_url] = true if options[:with_url].nil?
+
+      if options[:with_url]
+        playlist__web(owner_id, playlist_id, access_hash, options)
+      else
+        playlist__json(owner_id, playlist_id, access_hash, options)
       end
-      
-      Playlist.new(list, {
-        :id => id,
-        :owner_id => owner_id,
-        :access_hash => access_hash,
-        :title => title,
-        :subtitle => subtitle,
-      })
     end
     
+    ##
+    # @!macro [new] ua__options
+    #   @option options [Integer] :up_to (MAXIMUM_PLAYLIST_SIZE) maximum amount of audios to load.
+    #     If 0, no audios would be loaded (Just information about playlist).
+    #     If less than 0, will load whole playlist.
+    #
     # Get user or group audios.
     #
-    # ===== Parameters:
-    # * [+url+] (+String+) - URL to user or group.
-    # * [+up_to+] (+Integer+) - maximum amount of Audio to load.
+    # @note currently this method is only able to load 100 audios with download URL.
     #
-    # ===== Returns:
-    # * (+Playlist+)
-    def get_audios(url, up_to = nil)
-      if up_to && up_to > 100
-        Utility.warn("Current implementation of method VkMusic::Client#get_audios is only able to load first 100 audios from user page.")
-      end
-      # NOTICE: this method is only able to load first 100 audios
-      # NOTICE: it is possible to download 50 audios per request on "https://m.vk.com/audios#{owner_id}?offset=#{offset}", so it will cost A LOT to download all of audios (up to 200 requests).
-      # NOTICE: it is possible to load up to 2000 audios **without url** if offset is negative
-      
-      # Firstly, we need to get numeric id
-      id = get_id(url.to_s)      
-      
-      # Trying to parse out audios
+    # @overload audios(url, options)
+    #   @param url [String] URL to user/group page or audios.
+    #   @macro options_hash_param
+    #   @macro ua__options
+    #
+    # @overload audios(options)
+    #   @macro options_hash_param
+    #   @option options [Integer] :owner_id numerical ID of owner.
+    #   @macro ua__options
+    #
+    # @macro playlist_return
+    def audios(*args)
       begin
-        first_json = load_playlist_json_section(id.to_s, -1, 0)
-        first_data = first_json["data"][0]
-        first_data_audios = load_audios_from_data(first_data["list"])
-      rescue Exception => error
-        raise Exceptions::AudiosSectionParseError, "unable to load or parse audios section: #{error.message}", caller
+        case
+          when (args.size == 1 && String === args[0] ) ||
+               (args.size == 2 && String === args[0] && Hash === args[1])
+            owner_id = page_id(args[0].to_s)
+            options = args[1] || {}
+          when args.size == 1 && Hash === args[0]
+            owner_id = args[0][:owner_id].to_i
+            options = args[0]
+          else
+            raise
+        end
+      rescue
+        raise ArgumentError, "Bad arguments", caller
       end
-      
-      #total_count = first_data["totalCount"] # NOTICE: not used due to restrictions described above
-      total_count = first_data_audios.length # Using this instead
 
-      # TODO: Loading rest
+      options[:up_to]    ||= Constants::MAXIMUM_PLAYLIST_SIZE
 
-      up_to = total_count if (up_to.nil? || up_to < 0 || up_to > total_count)
-      list = first_data_audios.first(up_to)
-      
-      # It turns out user audios are just playlist with id -1
-      Playlist.new(list, {
-        :id => first_data["id"],
-        :owner_id => first_data["owner_id"],
-        :access_hash => first_data["access_hash"],
-        :title => CGI.unescapeHTML(first_data["title"].to_s),
-        :subtitle => CGI.unescapeHTML(first_data["subtitle"].to_s),
-      })
+      playlist__json(owner_id, -1, nil, options)
     end
 
-    # Get audios by their ids and secrets.
+    ##
+    # @!macro [new] wall__up_to_option
+    #   @option up_to [Integer] :up_to (10) maximum amount of audios to load from wall.
+    #   
+    # @!macro [new] wall__with_url_option
+    #   @option options [Boolean] :with_url (true) automatically use {Client#from_id} to get download URLs.
     #
-    # ===== Parameters:
-    # * [+arr+] (+Array+) - Array of objects, which can have different types: Audio or Array[owner_id, id, secret_1, secret_2].
+    # Get audios on wall of user or group starting with given post.
     #
-    # ===== Returns:
-    # * (+Array+) - array of audios with decoded URLs.
-    def get_audios_by_id(*arr)
-      if arr.size > 10
-        Utility.warn("Current implementation of method VkMusic::Client#get_audios_by_id is only able to handle first 10 audios.")
-        arr = arr.first(10)
-      end
-
-      arr.map! do |el| 
-        case el
-          when Array
-            el.join("_")
-          when Audio
-            "#{el.owner_id}_#{el.id}_#{el.secret_1}_#{el.secret_2}"
+    # @note this method is only able to load up to 91 audios from wall.
+    #
+    # @overload wall(url, options)
+    #   Load last audios from wall.
+    #   @param url [String] URL to user/group page.
+    #   @macro options_hash_param
+    #   @macro wall__up_to_option
+    #   @macro wall__with_url_option
+    #
+    # @overload wall(options)
+    #   Load audios starting from some exact post.
+    #   @macro options_hash_param
+    #   @option options [Integer] :owner_id numerical ID of wall owner.
+    #   @option options [Integer] :post_id numerical ID of post.
+    #   @macro wall__up_to_option
+    #   @macro wall__with_url_option
+    #
+    # @return [Array<Audio>] array of audios from wall. Possibly empty.
+    def wall(*args)
+      begin
+        case
+          when (args.size == 1 && args[0].class == String) ||
+               (args.size == 2 && args[0].class == String && args[1].class == Hash)
+            url = args[0].to_s
+            owner_id = page_id(url)
+            post_id = last_post_id(owner_id)
+            options = args[1] || {}
+            return [] if post_id.nil?
+          when args.length == 1 && Hash === args[0]
+            options = args[0]
+            owner_id = options[:owner_id].to_i
+            post_id = options[:post_id].to_i
           else
-            el.to_s
+            raise
         end
+      rescue Exceptions::ParseError => error
+        raise Exceptions::ParseError, "Unable to get last post id. Error: #{error.message}", caller
+      rescue
+        raise ArgumentError, "Bad arguments", caller
       end
-      json = load_audios_json_by_id(arr)
-      result = load_audios_from_data(json["data"][0].to_a)
-      raise Exceptions::ReloadAudiosParseError, "Result size don't match: excepected #{arr.size}, got #{result.size}", caller if result.size != arr.size
 
-      result
+      options[:up_to] ||= 10
+      options[:with_url] = true if options[:with_url].nil?
+
+      wall__json(owner_id, post_id, options)
     end
 
-    # Get audios on wall of user or group starting with given post.
+    ##
+    # Get audios attached to post.
     #
-    # ===== Parameters:
-    # * [+owner_id+] (+Integer+)
-    # * [+post_id+] (+Integer+)
-    # * [+up_to+] (+Integer+) - maximum amount of Audio to load.
+    # @overload post(url)
+    #   @param url [String] URL to post.
     #
-    # ===== Returns:
-    # * (+Array+) - array of audios with URLs.
-    def get_audios_from_wall(owner_id, post_id, up_to = nil)
+    # @overload post(options)
+    #   @macro options_hash_param
+    #   @option options [Integer] :owner_id numerical ID of wall owner.
+    #   @option options [Integer] :post_id numerical ID of post.
+    #
+    # @return [Array<Audio>] audios with download URLs.
+    def post(arg)
       begin
-        json = load_audios_json_from_wall(owner_id, post_id)
-        data = json["data"][0]
-        no_url_audios = load_audios_from_data(data["list"])
-      rescue Exception => error
-        raise Exceptions::WallParseError, "Failed to parse wall from #{@owner_id}_#{post_id}. Error: #{error.message}", caller
+        case arg
+          when String
+            owner_id, post_id = arg.match(Constants::Regex::VK_WALL_URL_POSTFIX).captures
+          when Hash
+            options = arg
+            owner_id = options[:owner_id].to_i
+            post_id = options[:post_id].to_i
+          else
+            raise
+        end
+      rescue
+        raise ArgumentError, "Bad arguments", caller
       end
 
-      up_to = no_url_audios.size if (up_to.nil? || up_to < 0 || up_to > no_url_audios.size)
-      no_url_audios = no_url_audios.first(up_to) 
-
-      list = get_audios_by_id(*no_url_audios)
-
-      Playlist.new(list, {
-        :id => data["id"],
-        :owner_id => data["owner_id"],
-        :access_hash => data["access_hash"],
-        :title => CGI.unescapeHTML(data["title"].to_s),
-        :subtitle => CGI.unescapeHTML(data["subtitle"].to_s),
-      })
+      amount = attached_audios_amount(owner_id: owner_id, post_id: post_id)
+      wall(owner_id: owner_id, post_id: post_id, up_to: amount)
     end
-    
-    # Get audios attached to post.
+
+    ##
+    # Get audios with download URLs by their IDs and secrets.
     #
-    # ===== Parameters:
-    # * [+url+] (+String+)
+    # @note warning: audios must not match.
     #
-    # ===== Returns:
-    # * (+Array+) - array of audios with URLs.
-    def get_audios_from_post(url)
-      url, owner_id, post_id = url.match(Constants::POST_URL_REGEX).to_a
-
-      amount = get_amount_of_audios_in_post(owner_id, post_id)
-      get_audios_from_wall(owner_id, post_id, amount).to_a
+    # @todo workaround for not unique audios in request
+    #
+    # @param args [Array<Audio, Array<(owner_id, audio_id, secret_1, secret_2)>, "#{owner_id}_#{id}_#{secret_1}_#{secret_2}">]
+    #
+    # @return [Array<Audio>] array of audios with download URLs.
+    def from_id(args)
+      begin
+        args.map! do |el| 
+          case el
+            when Array
+              el.join("_")
+            when Audio
+              "#{el.owner_id}_#{el.id}_#{el.secret_1}_#{el.secret_2}"
+            when String
+              el # Do not change
+            else
+              raise
+          end
+        end
+      rescue
+        raise ArgumentError, "Bad arguments", caller
+      end
+      
+      result = []
+      args.each_slice(10) do |subarray|
+        json = load__json__audios_by_id(subarray)
+        subresult = audios__from_data(json["data"][0].to_a)
+        raise Exceptions::ParseError, "Result size don't match: excepected #{subarray.size}, got #{subresult.size}", caller if subresult.size != subarray.size
+        result.concat(subresult)
+      end
+      result
     end
 
-    # Get user or group id.
+    ##
+    # @!endgroup
+
+    ##
+    # @!group Other
+
+    ##
+    # Get user or group ID. Sends one request if custom ID provided
     #
-    # ===== Parameters:
-    # * [+str+] (+String+) - link, id with prefix or custom id.
+    # @param str [String] link, ID with/without prefix or custom ID.
     #
-    # ===== Returns:
-    # * (+Integer+)
-    def get_id(str)
+    # @return [Integer] page ID.
+    def page_id(str)
+      raise ArgumentError, "Bad arguments", caller unless str.class == String
+
       case str
-        when Constants::VK_URL_REGEX
-          path = str.match(Constants::VK_URL_REGEX)[1]
-          get_id(path) # Recursive call
-        when Constants::VK_ID_REGEX
-          str
-        when Constants::VK_AUDIOS_REGEX
-          str.match(/-?\d+/).to_s # Numbers with sigh
-        when Constants::VK_PREFIXED_ID_REGEX
-          id = str.match(/\d+/).to_s # Just numbers. Sign needed
-          id = "-#{id}" unless str.start_with?("id")
-          id
-        when Constants::VK_CUSTOM_ID_REGEX
+        when Constants::Regex::VK_URL
+          path = str.match(Constants::Regex::VK_URL)[1]
+          id = page_id(path) # Recursive call
+        when Constants::Regex::VK_ID_STR
+          id = str.to_i
+        when Constants::Regex::VK_AUDIOS_URL_POSTFIX
+          id = str.match(/-?\d+/).to_s.to_i # Numbers with sign
+        when Constants::Regex::VK_PREFIXED_ID_STR
+          id = str.match(/\d+/).to_s.to_i # Just numbers. Sign needed
+          id *= -1 unless str.start_with?("id")
+        when Constants::Regex::VK_CUSTOM_ID
+          url = "#{Constants::URL::VK[:home]}/#{str}"
           begin
-            page = load_page("#{Constants::VK_URL[:home]}/#{str}")
-          rescue Exception => error
-            raise Exceptions::IdParseError, "unable to load page by id \"#{str}\". Error: #{error.message}"
-          end
+            page = load__page(url)
+          rescue Exceptions::RequestError => error
+            raise Exceptions::ParseError, "Failed request: #{error.message}", caller
+          end          
           
-          unless page.at_css(".PageBlock .owner_panel")
-            # Ensure this isn't some random vk page
-            raise Exceptions::IdParseError, "page #{str} doesn't seem to be a group or user page"
-          end
+          raise Exceptions::ParseError, "Page #{str} doesn't seem to be a group or user page", caller unless page.at_css(".PageBlock .owner_panel")
           
-          id = page.link_with(href: Constants::VK_HREF_ID_CONTAINING_REGEX).href.slice(/-?\d+/) # Numbers with sign
-          id
+          begin
+            id = page.link_with(href: Constants::Regex::VK_HREF_ID_CONTAINING).href.slice(Constants::Regex::VK_ID).to_i # Numbers with sign
+          rescue Exception => error
+            raise Exceptions::ParseError, "Unable to get user or group ID. Custom ID: #{str}. Error: #{error.message}", caller
+          end
       else
-        raise Exceptions::IdParseError, "unable to convert \"#{str}\" into id"
+        raise Exceptions::ParseError, "Unable to convert \"#{str}\" into ID", caller
       end
+      id
     end
 
+    ##
+    # Get ID of last post.
+    #
+    # @note requesting for "vk.com/id0" will raise ArgumentError.
+    #   Use +client.last_post_id(owner_id: client.id)+ to get last post of client.
+    #
+    # @overload last_post_id(url)
+    #   @param url [String] URL to wall owner.
+    #
+    # @overload last_post_id(owner_id)
+    #   @param owner_id [Integer] numerical ID of wall owner.
+    #
+    # @return [Integer, nil] ID of last post or +nil+ if there are no posts.
+    def last_post_id(arg)
+      begin
+        case arg
+          when String
+            path = arg.match(Constants::Regex::VK_URL)[1]
+          when Integer
+            owner_id = arg
+            path = "#{owner_id < 0 ? "club" : "id"}#{owner_id.abs}"
+          else
+            raise
+        end
+      rescue
+        raise ArgumentError, "Bad arguments", caller
+      end
+      raise ArgumentError, "Requesting this method for id0 is forbidden", caller if path == "id0"
+
+      url = "#{Constants::URL::VK[:home]}/#{path}"
+
+      begin
+        page = load__page(url)
+      rescue Exceptions::RequestError => error
+        raise Exceptions::ParseError, "Failed request: #{error.message}", caller
+      end
+
+      # Ensure this isn't some random vk page
+      raise Exceptions::ParseError, "Page at #{url} doesn't seem to be a group or user page", caller unless page.at_css(".PageBlock .owner_panel")
+
+      begin
+        posts = page.css(".wall_posts > .wall_item .post__anchor")
+        posts_ids = posts.map do |post|
+          post ? post.attribute("name").to_s.match(Constants::Regex::VK_POST_URL_POSTFIX)[2].to_i : 0
+        end
+        # To avoid checking id of pinned post need to take maximum id.
+        return posts_ids.max
+      rescue Exception => error
+        raise Exceptions::ParseError, "Unable to get last post on #{url}. Error: #{error.message}", caller
+      end
+    end
+
+    ##
     # Get amount of audios attached to specified post.
     #
-    # ===== Parameters:
-    # * [+owner_id+] (+Integer+)
-    # * [+post_id+] (+Integer+)
+    # @overload attached_audios_amount(url)
+    #   @param url [String] URL to post.
     #
-    # ===== Returns:
-    # * (+Integer+)
-    def get_amount_of_audios_in_post(owner_id, post_id)
+    # @overload attached_audios_amount(options)
+    #   @macro options_hash_param
+    #   @option options [Integer] :owner_id numerical ID of wall owner.
+    #   @option options [Integer] :post_id numerical ID of post.
+    #
+    # @return [Integer] amount of audios.
+    def attached_audios_amount(arg)
+      begin
+        case arg
+          when String
+            owner_id, post_id = arg.match(Constants::Regex::VK_WALL_URL_POSTFIX).captures
+          when Hash
+            options = arg
+            owner_id = options[:owner_id].to_i
+            post_id = options[:post_id].to_i
+          else
+            raise
+        end
+      rescue
+        raise ArgumentError, "Bad arguments", caller
+      end
+
+      url = "#{Constants::URL::VK[:wall]}#{owner_id}_#{post_id}"
+      begin
+        page = load__page(url)
+      rescue Exceptions::RequestError => error
+        raise Exceptions::ParseError, "Failed request: #{error.message}", caller
+      end
+
+      raise Exceptions::ParseError, "Post not found: #{owner_id}_#{post_id}", caller unless page.css(".service_msg_error").empty?
       begin
-        page = load_page("#{Constants::VK_URL[:wall]}#{owner_id}_#{post_id}")
         result = page.css(".wi_body > .pi_medias .medias_audio").size
       rescue Exception => error
-        raise Exceptions::PostParseError, "Unable to get amount of audios in post #{owner_id}_#{post_id}. Error: #{error.message}", caller
+        raise Exceptions::ParseError, "Unable to get amount of audios in post #{owner_id}_#{post_id}. Error: #{error.message}", caller
       end
-      raise Exceptions::PostParseError, "Post not found: #{owner_id}_#{post_id}", caller if result == 0 && !page.css(".service_msg_error").empty?
       result
     end
 
+    ##
+    # @!endgroup
 
     private
-    
-    # Loading pages
-    def load_page(url)
-      uri = URI(url) if url.class != URI      
-      @agent.get(uri)
+
+    # Load page by URL. And return Mechanize::Page.
+    def load__page(url)
+      uri = URI(url) if url.class != URI
+      Utility.debug("Loading #{uri}")
+      begin
+        @agent.get(uri)
+      rescue Exception => error
+        raise Exceptions::RequestError, error.message, caller
+      end
     end
-    def load_json(url)
-      page = load_page(url)
-      JSON.parse(page.body.strip)
+
+    # Load JSON by URL. And return JSON object.
+    def load__json(url)
+      page = load__page(url)
+      begin
+        JSON.parse(page.body.strip)
+      rescue Exception => error
+        raise Exceptions::ParseError, error.message, caller
+      end
     end
-    
-    def load_playlist_page(options)
-      uri = URI(Constants::VK_URL[:audios])
+
+
+    # Load playlist web page.
+    def load__page__playlist(owner_id, playlist_id, access_hash, options)
+      uri = URI(Constants::URL::VK[:audios])
       uri.query = Utility.hash_to_params({
-        "act" => "audio_playlist#{options[:owner_id]}_#{options[:id]}",
-        "access_hash" => options[:access_hash].to_s,
+        "act" => "audio_playlist#{owner_id.to_i}_#{playlist_id.to_i}",
+        "access_hash" => access_hash.to_s,
         "offset" => options[:offset].to_i
       })
-      load_page(uri)
+      load__page(uri)
     end
-    def load_playlist_json_section(owner_id, playlist_id, offset = 0)
-      uri = URI(Constants::VK_URL[:audios])
+
+    # Load JSON playlist part with +load_section+ request.
+    def load__json__playlist_section(owner_id, playlist_id, access_hash, options)
+      uri = URI(Constants::URL::VK[:audios])
       uri.query = Utility.hash_to_params({
         "act" => "load_section",
-        "owner_id" => owner_id,
-        "playlist_id" => playlist_id,
+        "owner_id" => owner_id.to_i,
+        "playlist_id" => playlist_id.to_i,
+        "access_hash" => access_hash.to_s,
         "type" => "playlist",
-        "offset" => offset,
+        "offset" => options[:offset].to_i,
         "utf8" => true
       })
-      begin
-        load_json(uri)
-      rescue Exception => error
-        raise Exceptions::AudiosSectionParseError, "unable to load or parse audios section: #{error.message}", caller
-      end
+      load__json(uri)
     end
 
-    def load_audios_json_by_id(ids)
-      uri = URI(Constants::VK_URL[:audios])
+
+    # Load JSON audios with +reload_audio+ request.
+    def load__json__audios_by_id(ids)
+      uri = URI(Constants::URL::VK[:audios])
       uri.query = Utility.hash_to_params({
         "act" => "reload_audio",
-        "ids" => ids,
+        "ids" => ids.to_a,
         "utf8" => true
       })
-      begin
-        load_json(uri)
-      rescue Exception => error
-        raise Exceptions::AudiosSectionParseError, "unable to load or parse audios section: #{error.message}", caller
-      end
+      load__json(uri)
     end
 
-    def load_audios_json_from_wall(owner_id, post_id)
-      uri = URI(Constants::VK_URL[:audios])
+    # Load JSON audios with +load_section+ from wall.
+    def load__json__audios_wall(owner_id, post_id)
+      uri = URI(Constants::URL::VK[:audios])
       uri.query = Utility.hash_to_params({
         "act" => "load_section",
         "owner_id" => owner_id,
@@ -337,43 +528,145 @@ module VkMusic
         "wall_type" => "own",
         "utf8" => true
       })
+      load__json(uri)
+    end
+
+
+    # Loading audios from web page.
+    def audios__from_page(obj)
+      page = obj.class == Mechanize::Page ? obj : load__page(obj)
       begin
-        load_json(uri)
+        page.css(".audio_item.ai_has_btn").map { |elem| Audio.from_node(elem, @id) }
       rescue Exception => error
-        raise Exceptions::AudiosSectionParseError, "unable to load or parse audios section: #{error.message}", caller
+        raise Exceptions::ParseError, error.message, caller
       end
-    end
-    
-    
-    # Loading audios
-    def load_audios_from_page(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 load_audios_from_data(data)
-      data.map { |audio_data| Audio.from_data_array(audio_data, @id) }
+
+    # Load audios from JSON data.
+    def audios__from_data(data)
+      begin
+        data.map { |audio_data| Audio.from_data(audio_data, @id) }
+      rescue Exception => error
+        raise Exceptions::ParseError, error.message, caller
+      end
     end
-    
-    
+
+
+    # Load playlist through web page requests.
+    def playlist__web(owner_id, playlist_id, access_hash, options)
+      begin
+        # Load first page and get info
+        first_page = load__page__playlist(owner_id, playlist_id, access_hash, offset: 0)
+        
+        # Parse out essential data
+        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
+      rescue Exception => error
+        raise Exceptions::ParseError, error.message, caller
+      end
+      # Now we can be sure we are on correct page
+      
+      first_page_audios = audios__from_page(first_page)
+      
+      # Check whether need to make additional requests
+      options[:up_to] = playlist_size if (options[:up_to] < 0 || options[:up_to] > playlist_size)
+      list = first_page_audios[0, options[:up_to]]
+      while list.length < options[:up_to] do
+        playlist_page = load__page__playlist(owner_id, playlist_id, access_hash, offset: list.length)
+        list.concat(audios__from_page(playlist_page)[0, options[:up_to] - list.length])
+      end
+      
+      Playlist.new(list, {
+        :id => id,
+        :owner_id => owner_id,
+        :access_hash => access_hash,
+        :title => title,
+        :subtitle => subtitle,
+      })
+    end
+
+    # Load playlist through JSON requests.
+    def playlist__json(owner_id, playlist_id, access_hash, options)
+      if options[:up_to] < 0 || options[:up_to] > 100
+        Utility.warn("Current implementation of this method is not able to return more than 100 first audios with URL.")
+      end
+
+      # Trying to parse out audios
+      begin
+        first_json = load__json__playlist_section(owner_id, playlist_id, access_hash, offset: 0)
+        first_data = first_json["data"][0]
+        first_data_audios = audios__from_data(first_data["list"])
+      rescue Exception => error
+        raise Exceptions::ParseError, error.message, caller
+      end
+      
+      total_count = first_data["totalCount"]
+      options[:up_to] = total_count if (options[:up_to] < 0 || options[:up_to] > total_count)
+      list = first_data_audios[0, options[:up_to]]
+      while list.length < options[:up_to] do
+        json = load__json__playlist_section(owner_id, playlist_id, access_hash,
+          offset: list.length
+        )
+        audios = audios__from_data(json["data"][0]["list"])
+        list.concat(audios[0, options[:up_to] - list.length])
+      end
+      
+      Playlist.new(list, {
+        :id => first_data["id"],
+        :owner_id => first_data["owner_id"],
+        :access_hash => first_data["access_hash"],
+        :title => CGI.unescapeHTML(first_data["title"].to_s),
+        :subtitle => CGI.unescapeHTML(first_data["subtitle"].to_s),
+      })
+    end
+
+    # Load audios from wall using JSON request.
+    def wall__json(owner_id, post_id, options)
+      if options[:up_to] < 0 || options[:up_to] > 91
+        options[:up_to] = 91
+        Utility.warn("Current implementation of this method is not able to return more than 91 audios from wall.")
+      end
+
+      begin
+        json = load__json__audios_wall(owner_id, post_id)
+        data = json["data"][0]
+        audios = audios__from_data(data["list"])[0, options[:up_to]]
+      rescue Exception => error
+        raise Exceptions::ParseError, error.message, caller
+      end
+      options[:with_url] ? from_id(audios) : audios
+    end
+
+
     # Login
     def login(username, password)
+      Utility.debug("Logging in.")
       # Loading login page
-      homepage = load_page(Constants::VK_URL[:home])
+      homepage = load__page(Constants::URL::VK[:home])
       # Submitting login form
-      login_form = homepage.forms.find { |form| form.action.start_with?(Constants::VK_URL[:login_action]) }
+      login_form = homepage.forms.find { |form| form.action.start_with?(Constants::URL::VK[:login_action]) }
       login_form[Constants::VK_LOGIN_FORM_NAMES[:username]] = username.to_s
       login_form[Constants::VK_LOGIN_FORM_NAMES[:password]] = password.to_s
       after_login = @agent.submit(login_form)
 
       # Checking whether logged in
-      raise Exceptions::LoginError, "unable to login. Redirected to #{after_login.uri.to_s}", caller unless after_login.uri.to_s == Constants::VK_URL[:feed]
+      raise Exceptions::LoginError, "Unable to login. Redirected to #{after_login.uri.to_s}", caller unless after_login.uri.to_s == Constants::URL::VK[:feed]
       
       # Parsing information about this profile
-      profile = load_page(Constants::VK_URL[:profile])      
-      @name = profile.title
-      @id = profile.link_with(href: Constants::VK_HREF_ID_CONTAINING_REGEX).href.slice(/\d+/)
+      profile = load__page(Constants::URL::VK[:profile])      
+      @name = profile.title.to_s
+      @id = profile.link_with(href: Constants::Regex::VK_HREF_ID_CONTAINING).href.slice(/\d+/).to_i
     end
     
+    # Shortcut
     def unmask_link(link)
       VkMusic::LinkDecoder.unmask_link(link, @id)
     end