vk 0.0.4 → 0.6.5.53

data/lib/vk/post/wall.rb

@@ -5,8 +5,6 @@ require 'delegate'
 module Vk
   class Post
     class Wall
-      extend ActiveSupport::Memoizable
-
       attr_accessor :uid, :count, :posts
 
       def initialize(uid, count, posts)
@@ -14,16 +12,14 @@ module Vk
       end
 
       def user
-        Vk::User.find(uid)
+        @user ||= Vk::User.find(uid)
       end
-      memoize :user
 
       def [](index)
         raise "Post #{index} is not exist"  if index > count + 1
         load_posts_to(index)                if index >= loaded_posts
-        if post = posts[index]
-          Vk::Post.find(Vk::Post.id_for(post), data: post)
-        end
+        post = posts[index]
+        Vk::Post.find(Vk::Post.id_for(post), data: post) if post
       end
 
       def first; self[0]; end

data/lib/vk/prompt.rb

@@ -0,0 +1,43 @@
+require 'vk'
+require 'active_support/concern'
+
+module Vk
+  begin
+    require 'tty-prompt'
+    Prompt = TTY::Prompt
+  rescue LoadError
+    class Prompt
+      # @param [String] message
+      # @param [Hash] _options
+      def say(message = '', _options = {})
+        puts(message)
+      end
+
+      def ask(message = '', *_args, &_block)
+        print(message << ' ')
+        gets.chomp
+      end
+    end
+  end
+
+  module PromptExtension
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # @return [TTY::Prompt]
+      def prompt
+        @prompt ||= Prompt.new
+      end
+      attr_writer :prompt
+    end
+
+    private
+
+    # @return [TTY::Prompt]
+    def prompt
+      @prompt ||= self.class.prompt
+    end
+
+    attr_writer :prompt
+  end
+end

data/lib/vk/region.rb

@@ -0,0 +1,15 @@
+require 'vk/base'
+
+module Vk
+  class Region < Base
+    self.fields = [:id, :title, :country_id]
+
+    def country
+      @country ||= Vk::Country.find(country_id)
+    end
+
+    def to_s
+      title
+    end
+  end
+end

data/lib/vk/result.rb

@@ -0,0 +1,85 @@
+module Vk
+  class Result
+    include Enumerable
+
+    # @example
+    #   Vk::Result.new('database.getCountries', Vk::Country, options)
+    def initialize(method, items_class, options = {}, merged_attributes = {})
+      @items = []
+      @amount = 0
+      @client = options.delete(:client) { Vk.client }
+      @items_class = items_class
+      @method = method
+      @options = options
+      @options[:offset] ||= 0
+      @options[:count] ||= 100
+      @merged_attributes = merged_attributes
+    end
+
+    # @return [Fixnum]
+    def count
+      load_items unless @count
+      @count
+    end
+
+    # @return [Fixnum]
+    def amount
+      @items.size
+    end
+
+    # @return [<Vk::Base>]
+    attr_reader :items
+
+    def each(&block)
+      @items.each do |item|
+        block.call(item)
+      end
+      while amount && count && amount < count
+        increase_offset!
+        load_items(&block)
+      end
+    end
+
+    # @return [<Vk::Base>]
+    def all
+      while amount && count && amount < count
+        increase_offset!
+        load_items
+      end
+      @items
+    end
+
+    def method_missing(name, *arguments, &block)
+      if respond_to_missing?(name, false)
+        @items_class.public_send(name, *arguments, &block)
+      else
+        super
+      end
+    end
+
+    # @param [String] name
+    # @param [Boolean] include_all
+    def respond_to_missing?(name, include_all)
+      @items_class.respond_to?(name, include_all)
+    end
+
+    private
+
+    def increase_offset!
+      @options[:offset] = amount
+    end
+
+    def load_items(&block)
+      raise Vk::TooMuchArguments.new(@method, 'count', 1000) if @options[:count].try(:>, 1000)
+      data = @client.request(@method, @options)
+      return unless data
+      @count = data['count']
+      sleep 0.5
+      data['items'].each do |item|
+        item = @items_class.new(item.merge(@merged_attributes))
+        @items << item
+        block.call(item) if block_given?
+      end
+    end
+  end
+end

data/lib/vk/stats.rb

@@ -0,0 +1,114 @@
+require 'vk'
+require 'vk/base'
+require 'active_support/core_ext/module/attribute_accessors'
+
+module Vk
+  module Stats
+    TIME_FORMAT = '%Y-%m-%d'
+
+    module_function
+
+    mattr_accessor :loader
+
+    self.loader = Vk.client
+
+    # @param [Hash] options
+    # @option options [Fixnum] :group_id
+    # @option options [Fixnum] :app_id
+    # @option options [#to_date] :date_from
+    # @option options [#to_date] :date_to
+    def get(options = {})
+      options[:date_from] = options[:date_from].to_date.strftime(TIME_FORMAT) if options.key?(:date_from)
+      options[:date_to] = options[:date_to].to_date.strftime(TIME_FORMAT) if options.key?(:date_to)
+      result = loader.request('stats.get', options)
+      result.map { |period| Period.new(period['day'], data: period) } if result
+    end
+
+    class Period < Vk::Base
+      self.key_field = :day
+      self.fields = [
+        :views, :visitors, :reach, :reach_subscribers, :subscribed, :unsubscribed, :sex, :age, :sex_age, :cities, :countries
+      ]
+
+      def date
+        @date ||= Date.parse(read_attribute(:day))
+      end
+
+      def sex
+        @sex ||= (read_attribute(:sex) || []).map do |sex|
+          Vk::Stats::Sex.new(nil, data: sex) if sex
+        end.compact
+      end
+
+      def age
+        @age ||= (read_attribute(:age) || []).map do |age|
+          Vk::Stats::Age.new(nil, data: age) if age
+        end.compact
+      end
+
+      def sex_age
+        @sex_age ||= (read_attribute(:sex_age) || []).map do |sex_age|
+          Vk::Stats::SexAge.new(nil, data: sex_age) if sex_age
+        end.compact
+      end
+
+      def cities
+        @cities ||= (read_attribute(:cities) || []).map do |city|
+          Vk::Stats::City.new(nil, data: city) if city
+        end.compact
+      end
+
+      def countries
+        @countries ||= (read_attribute(:countries) || []).map do |country|
+          Vk::Stats::Country.new(nil, data: country) if country
+        end.compact
+      end
+
+      private
+
+      def load_data(*)
+      end
+    end
+
+    class Sex < Vk::Base
+      self.key_field = :value
+      self.fields = [:visitors]
+    end
+
+    class Age < Vk::Base
+      self.key_field = :value
+      self.fields = [:visitors]
+    end
+
+    class SexAge < Vk::Base
+      self.key_field = :value
+      self.fields = [:visitors]
+
+      def sex
+        split_sex_age
+        @sex
+      end
+
+      def age
+        split_sex_age
+        @age
+      end
+
+      private
+      def split_sex_age
+        return if @sex && @age
+        @sex, @age = value.split(';')
+      end
+    end
+
+    class City < Vk::Base
+      self.key_field = :value
+      self.fields = [:name, :visitors]
+    end
+
+    class Country < Vk::Base
+      self.key_field = :value
+      self.fields = [:name, :visitors, :code]
+    end
+  end
+end

data/lib/vk/street.rb

@@ -0,0 +1,17 @@
+require 'vk/base'
+
+module Vk
+  class Street < Base
+    self.fields = [:id, :title]
+
+    def to_s
+      title
+    end
+
+    protected
+
+    def load_data(options = {})
+      @attributes = @attributes.merge(loader.get_street_by_id(id))
+    end
+  end
+end

data/lib/vk/user.rb

@@ -2,18 +2,27 @@ require 'vk/base'
 
 module Vk
   class User < Base
-    self.key_field = :uid
-    self.fields = [:uid, :first_name, :last_name, :nickname, :domain, :sex, :bdate, :birthdate, :city, :country, :timezone, :photo, :photo_medium, :photo_big, :has_mobile, :rate, :contacts, :education, :online]
-
-    class << self
-      def find_all(ids, options = {})
-        loaded_ids = ids & identity_map.keys
-        ids_to_load = ids - loaded_ids
-        identity_map.values_at(*loaded_ids).tap do |results|
-          if ids_to_load.any?
-            results += loader.get_profiles(ids_to_load, options).map do |profile|
-              new(profile['uid'], data: profile)
-            end
+    RELATION_MAPPING = {
+      0 => nil,
+      1 => :single,
+      2 => :friendship,
+      3 => :plight,
+      4 => :married,
+      5 => :complicated,
+      6 => :looking,
+      7 => :love
+    }
+
+    self.key_field = :id
+    self.fields = %i(id first_name last_name deactivated hidden sex bdate city country photo_50 photo_100 photo_200_orig photo_200 photo_400_orig photo_max photo_max_orig photo_id online online_mobile domain has_mobile contacts connections site education universities schools can_post can_see_all_posts can_see_audio can_write_private_message status last_seen common_count relation relatives counters screen_name maiden_name timezone occupation activities interests music movies tv books games about quotes personal)
+
+    def self.find_all(ids, options = {})
+      loaded_ids = ids & identity_map.keys
+      ids_to_load = ids - loaded_ids
+      identity_map.values_at(*loaded_ids).tap do |results|
+        if ids_to_load.any?
+          results += loader.get_users(ids_to_load, options).map do |profile|
+            new(profile['id'], data: profile)
           end
         end
       end
@@ -21,58 +30,132 @@ module Vk
 
     attr_accessor :posts_count
 
+    # @return [String]
     def name
-      "#{first_name} #{last_name}"
+      @name ||= "#{first_name} #{last_name}"
+    end
+
+    # @return [Date]
+    def born_on
+      @born_on ||= Date.strptime(bdate, '%d.%m.%Y') if born_on?
     end
-    memoize :name
 
+    def born_on?
+      read_attribute(:bdate).to_s.split(/\./).size == 3
+    end
+
+    # @return [:unknown, :female, :male]
+    def gender
+      {
+        0 => :unknown,
+        1 => :female,
+        2 => :male
+      }[sex]
+    end
+
+    # @return [Fixnum]
     def city_id
       read_attribute(:city)
     end
 
+    # @return [Vk::City]
     def city
-      Vk::City.find(city_id)
+      @city ||= Vk::City.find(city_id)
     end
-    memoize :city
 
+    # @return [Fixnum]
     def country_id
       read_attribute(:country)
     end
 
+    # @return [Vk::Country]
     def country
-      Vk::Country.find(country_id)
+      @country ||= Vk::Country.find(country_id)
     end
-    memoize :country
 
-    def friend_ids
-      loader.get_friends(uid)
+    # @return [<Fixnum>]
+    def friend_ids(options = {})
+      @friend_ids ||= loader.get_friends(id, options = {})
     end
-    memoize :friend_ids
 
+    # @param [<Vk::User>] options
     def friends(options = {})
-      User.find_all(friend_ids, options)
+      @friends ||= {}
+      @friends[options] ||=
+        if options[:fields]
+          loader.get_friends(id, options).all
+        else
+          User.find_all(friend_ids)
+        end
+    end
+
+    # @return [<Vk::Photo>]
+    def profile_photos
+      @profile_photos ||= loader.get_photos(id, 'profile').all
+    end
+
+    # @return [Boolean]
+    def deactivated?
+      read_attribute(:deactivated)
     end
-    memoize :friends
 
+    def relation_type
+      RELATION_MAPPING[relation]
+    end
+
+    # @return [Vk::User]
+    def relation_partner
+      partner = read_attribute(:relation_partner)
+      Vk::User.new(partner) if partner
+    end
+
+    # @return [<Vk::Audio::Album>]
+    def audio_albums
+      @audio_albums ||= loader.get_audio_albums(id).all
+    end
+
+    # @return [<Vk::Audio>]
+    def audios
+      @audios ||= loader.get_audios(id).all
+    end
+
+    # @return [String]
     def to_s
       name
     end
 
+    # @param [Vk::Wall] options
     def wall(options = {})
-      count, *posts = loader.get_wall(id, options)
-      Vk::Post::Wall.new(id, count, posts)
+      @wall ||= {}
+      @wall[options] ||=
+        begin
+          count, *posts = loader.get_wall(id, options)
+          Vk::Post::Wall.new(id, count, posts)
+        end
     end
-    memoize :wall
+
     alias posts wall
 
+    # @return [Fixnum]
     def posts_count
       wall.count
     end
 
+    # @param [Hash] options
+    # @see Vk::Request.get_groups
+    # @return [<Vk::Group>]
+    def groups(options = {})
+      @groups ||= {}
+      options[:extended] = true
+      index = options.hash
+      @groups[index] ||= loader.get_groups(id, options)
+      @groups[index].all
+    end
+
     protected
 
-    def load_data(options = {})
-      @attributes = @attributes.merge(loader.get_profile(id, options))
+    def load_data(options = { fields: self.class.fields })
+      @attributes = @attributes.merge(loader.get_user(id, options))
     end
   end
 end