vkontakte_api 1.2 → 1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d37878c023a9ef41c525a2e80d94a1116bf7cdf4
-  data.tar.gz: d6bee0ae8a1dfa7a74d74e26327f5cf880214e9b
+  metadata.gz: 60dffad7bbac6d779ff73eaeb39221648bd06b81
+  data.tar.gz: c702f943689840e842d49859f2bcc87b10fce869
 SHA512:
-  metadata.gz: 100e3698409e4c1c76ac1adbbb75609675b92c965905e5218b32cc5f1dae49d0f69783db01bb7ca5729e724bae8e4718e0f3ffc7cb8ec8cc86a87a7e0d399301
-  data.tar.gz: 43b9a423fd114d904b395f34fdf510eb72a48657722b2a88c2e15f82bdb8544b6aa2180fe8eb225a3e28aec20b12bbf3bc31cabb788f1f34739f62457d7ada19
+  metadata.gz: fc49252ddc7b95434e0f2f5ac59cb4ea4f749c1a30a7026b1bbefa5f570ae836f3b25125f70c9f8026aee2322b5cd4f878e19d90bc9a90f26948951f250d14b8
+  data.tar.gz: 90a2c6d2da5ac5e7e08851575373c7bc5e53684a88d5111e7a128026d3aa2accfb8b5c41bd2bedc373b3759009cf35d68c1132eb2f55691da93f37438fc9a1b0

data/.gitignore

@@ -2,5 +2,6 @@
 .bundle
 Gemfile.lock
 pkg/*
+tmp/*
 .yardoc/*
 spec/support/credentials.yml

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 1.3 (01.11.2013)
+
+* Корректная работа API-методов `*.search` (спасибо [leonko](https://github.com/leonko))
+* Поддержка IO-объектов в методе `upload` (спасибо [undr](https://github.com/undr))
+
 ## 1.2 (14.07.2013)
 
 * Повтор запроса при определенных ошибках

data/Guardfile

@@ -1,7 +1,9 @@
-guard 'rspec' do
+guard 'rspec', all_on_start: true, all_after_pass: true do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { 'spec' }
+  
+  watch('spec/support/mechanized_authorization.rb') { 'spec/integration_spec.rb' }
 end
 
 notification :terminal_notifier, activate: 'com.googlecode.iTerm2'

data/README.md

@@ -6,7 +6,7 @@
 
 ``` ruby
 # Gemfile
-gem 'vkontakte_api', '~> 1.2'
+gem 'vkontakte_api', '~> 1.3'
 ```
 
 или просто
@@ -47,7 +47,7 @@ users.first.last_name  # => "Дуров"
 # то блок будет выполнен для каждого элемента,
 # и метод вернет обработанный массив
 fields = [:first_name, :last_name, :screen_name]
-@vk.friends.get(fields: fields) do |friend|
+@vk.friends.get(uid: 2, fields: fields) do |friend|
   "#{friend.first_name} '#{friend.screen_name}' #{friend.last_name}"
 end
 # => ["Павел 'durov' Дуров"]
@@ -64,6 +64,13 @@ url = 'http://cs303110.vkontakte.ru/upload.php?act=do_add'
 VkontakteApi.upload(url: url, photo: ['/path/to/file.jpg', 'image/jpeg'])
 ```
 
+Если загружаемый файл доступен как открытый IO-объект, его можно передать альтернативным синтаксисом - IO-объект, MIME-тип и путь к файлу:
+
+``` ruby
+url = 'http://cs303110.vkontakte.ru/upload.php?act=do_add'
+VkontakteApi.upload(url: url, photo: [file_io, 'image/jpeg', '/path/to/file.jpg'])
+```
+
 Метод вернет ответ сервера ВКонтакте, преобразованный в `Hashie::Mash`; его можно использовать при вызове метода API на последнем этапе процесса загрузки.
 
 ### Авторизация
@@ -262,7 +269,6 @@ $ rails generate vkontakte_api:install
 
 ## Roadmap
 
-* настраиваемый retry запроса при стандартных исключениях
 * CLI-интерфейс с автоматической авторизацией
 
 ## Участие в разработке

data/lib/vkontakte_api/client.rb

@@ -69,6 +69,16 @@ module VkontakteApi
       end.keys
     end
     
+    # If the called method is a namespace, it creates and returns a new `VkontakteApi::Namespace` instance.
+    # Otherwise it creates a `VkontakteApi::Method` instance and calls it passing the arguments and a block.
+    def method_missing(*args, &block)
+      if Namespace.exists?(args.first)
+        create_namespace(args.first)
+      else
+        call_method(args, &block)
+      end
+    end
+    
   private
     def settings
       @settings ||= self.get_user_settings

data/lib/vkontakte_api/namespace.rb

@@ -1,7 +1,36 @@
 module VkontakteApi
-  # An API method namespace (such as `users` or `friends`). It just includes `Resolvable` and `Resolver`.
+  # An API method namespace (such as `users` or `friends`).
+  # 
+  # It includes `Resolvable` and `Resolver` and calls API methods via `Resolver#call_method`.
+  # It also holds the list of all known namespaces.
   class Namespace
     include Resolvable
     include Resolver
+    
+    # Creates and calls the `VkontakteApi::Method` using `VkontakteApi::Resolver#call_method`.
+    def method_missing(*args, &block)
+      call_method(args, &block)
+    end
+    
+    class << self
+      # An array of all method namespaces.
+      # 
+      # Lazily loads the list from `namespaces.yml` and caches it.
+      # @return [Array] An array of strings
+      def names
+        if @names.nil?
+          filename = File.expand_path('../namespaces.yml', __FILE__)
+          @names   = YAML.load_file(filename)
+        end
+        
+        @names
+      end
+      
+      # Does a given namespace exist?
+      # @param [String, Symbol] name
+      def exists?(name)
+        names.include?(name.to_s)
+      end
+    end
   end
 end

data/lib/vkontakte_api/resolvable.rb

@@ -7,7 +7,7 @@ module VkontakteApi
     # @param [String] name The name of this resolvable.
     # @option options [Hashie::Mash] :resolver A mash holding information about the previous resolver.
     def initialize(name, options = {})
-      @name = name
+      @name = name.to_s
       @previous_resolver = options.delete(:resolver)
     end
     

data/lib/vkontakte_api/resolver.rb

@@ -1,41 +1,26 @@
 module VkontakteApi
   # A mixin for classes that will resolve other classes' objects via `#method_missing`.
   module Resolver
-    # Main methods dispatch.
-    # 
-    # If the called method is a namespace, it creates and returns a new `VkontakteApi::Namespace` instance.
-    # Otherwise it creates a `VkontakteApi::Method` instance and invokes it's `#call` method passing it the arguments and a block.
-    def method_missing(method_name, *args, &block)
-      method_name = method_name.to_s
-      
-      if Resolver.namespaces.include?(method_name)
-        # called from Client
-        Namespace.new(method_name, resolver: resolver)
-      else
-        # called from Namespace or one-level method
-        Method.new(method_name, resolver: resolver).call(args.first || {}, &block)
-      end
-    end
-    
     # A `Hashie::Mash` structure holding the name and token of current instance.
     # @return [Hashie::Mash]
     def resolver
       @resolver ||= Hashie::Mash.new(name: @name, token: token)
     end
     
+  private
+    def create_namespace(name)
+      Namespace.new(name, resolver: resolver)
+    end
+    
+    def create_method(name)
+      Method.new(name, resolver: resolver)
+    end
+    
+    def call_method(args, &block)
+      create_method(args.shift).call(args.first || {}, &block)
+    end
+    
     class << self
-      # An array of method namespaces.
-      # Lazily loads the list from `namespaces.yml` and caches it.
-      # @return [Array]
-      def namespaces
-        if @namespaces.nil?
-          filename    = File.expand_path('../namespaces.yml', __FILE__)
-          @namespaces = YAML.load_file(filename)
-        end
-        
-        @namespaces
-      end
-      
       # When this module is included, it undefines the `:send` instance method in the `base_class`
       # so it can be resolved via `method_missing`.
       def included(base_class)

data/lib/vkontakte_api/uploading.rb

@@ -12,15 +12,15 @@ module VkontakteApi
     #   VkontakteApi.upload(
     #     url:   'http://example.com/upload',
     #     file1: ['/path/to/file1.jpg', 'image/jpeg'],
-    #     file2: ['/path/to/file2.png', 'image/png']
+    #     file2: [io_object, 'image/png', '/path/to/file2.png']
     #   )
     def upload(params = {})
       url = params.delete(:url)
       raise ArgumentError, 'You should pass :url parameter' unless url
       
       files = {}
-      params.each do |param_name, (file_path, file_type)|
-        files[param_name] = Faraday::UploadIO.new(file_path, file_type)
+      params.each do |param_name, (file_path_or_io, file_type, file_path)|
+        files[param_name] = Faraday::UploadIO.new(file_path_or_io, file_type, file_path)
       end
       
       API.connection.post(url, files).body

data/lib/vkontakte_api/version.rb

@@ -1,4 +1,4 @@
 module VkontakteApi
   # Library version.
-  VERSION = '1.2'
+  VERSION = '1.3'
 end

data/spec/integration_spec.rb

@@ -13,70 +13,67 @@ describe "Integration" do
   end
   
   describe "unauthorized requests" do
-    before(:each) do
-      @vk = VK::Client.new
-    end
+    let(:vk) { VK::Client.new }
     
     it "get users" do
-      user = @vk.users.get(uid: 1).first
-      user.uid.should == 1
-      user.last_name.should_not be_empty
-      user.first_name.should_not be_empty
+      user = vk.users.get(uid: 1).first
+      expect(user.uid).to eq(1)
+      expect(user.last_name).not_to be_empty
+      expect(user.first_name).not_to be_empty
+    end
+    
+    it "search newsfeed" do
+      news = vk.newsfeed.search(q: 'vk', count: 1)
+      expect(news).to be_a(Enumerable)
     end
   end
   
   if MechanizedAuthorization.on?
     describe "authorized requests" do
-      before(:each) do
-        @vk = MechanizedAuthorization.client
-      end
+      let(:vk) { MechanizedAuthorization.client }
       
       it "get groups" do
-        groups = @vk.groups.get
-        groups.should include(1)
+        pending 'MechanizedAuthorization not working'
+        expect(vk.groups.get).to include(1)
       end
     end
     
     describe "requests with camelCase and predicate methods" do
-      before(:each) do
-        @vk = MechanizedAuthorization.client
-      end
+      let(:vk) { MechanizedAuthorization.client }
       
       it "convert method names to vk.com format" do
-        @vk.is_app_user?.should be_true
+        pending 'MechanizedAuthorization not working'
+        expect(vk.is_app_user?).to be_true
       end
     end
   end
   
   describe "requests with array arguments" do
-    before(:each) do
-      @vk = VK::Client.new
-    end
+    let(:vk) { VK::Client.new }
     
     it "join arrays with a comma" do
-      users = @vk.users.get(uids: [1, 2, 3], fields: %w[first_name last_name screen_name])
-      users.first.screen_name.should_not be_empty
+      users = vk.users.get(uids: [1, 2, 3], fields: %w[first_name last_name screen_name])
+      expect(users.first.screen_name).not_to be_empty
     end
   end
   
   describe "requests with blocks" do
-    before(:each) do
-      @vk = VK::Client.new
-    end
+    let(:vk) { VK::Client.new }
     
     it "map the result with a block" do
-      users = @vk.users.get(uid: 1) do |user|
+      users = vk.users.get(uid: 1) do |user|
         "#{user.last_name} #{user.first_name}"
       end
       
-      users.first.should_not be_empty
+      expect(users.first).not_to be_empty
     end
   end
   
   describe "authorization" do
     context "with a scope" do
       it "returns a correct url" do
-        VK.authorization_url(scope: %w[friends groups]).should include('scope=friends%2Cgroups')
+        url = VK.authorization_url(scope: %w[friends groups])
+        expect(url).to include('scope=friends%2Cgroups')
       end
     end
   end

data/spec/vkontakte_api/api_spec.rb

@@ -23,13 +23,13 @@ describe VkontakteApi::API do
     
     context "called with a token parameter" do
       it "sends it to .connection" do
-        subject.should_receive(:connection).with(url: VkontakteApi::API::URL_PREFIX, token: 'token')
+        expect(subject).to receive(:connection).with(url: VkontakteApi::API::URL_PREFIX, token: 'token')
         subject.call('apiMethod', { some: :params }, 'token')
       end
     end
     
     it "returns the response body" do
-      subject.call('apiMethod').should == @result
+      expect(subject.call('apiMethod')).to eq(@result)
     end
     
     it "uses an HTTP verb from VkontakteApi.http_verb" do
@@ -37,7 +37,7 @@ describe VkontakteApi::API do
       VkontakteApi.http_verb = http_verb
       
       response = double("Response", body: double)
-      @connection.should_receive(:send).with(http_verb, 'apiMethod', {}).and_return(response)
+      expect(@connection).to receive(:send).with(http_verb, 'apiMethod', {}).and_return(response)
       subject.call('apiMethod')
     end
     
@@ -51,27 +51,27 @@ describe VkontakteApi::API do
       faraday_options = double("Faraday options")
       VkontakteApi.stub(:faraday_options).and_return(faraday_options)
       url = double("URL")
-      Faraday.should_receive(:new).with(url, faraday_options)
-      connection = subject.connection(url: url)
+      
+      expect(Faraday).to receive(:new).with(url, faraday_options)
+      subject.connection(url: url)
     end
     
     context "without a token" do
       it "creates a connection without an oauth2 middleware" do
-        connection = subject.connection
-        connection.builder.handlers.map(&:name).should_not include('FaradayMiddleware::OAuth2')
+        handler_names = subject.connection.builder.handlers.map(&:name)
+        expect(handler_names).not_to include('FaradayMiddleware::OAuth2')
       end
     end
     
     context "with a token" do
-      before(:each) do
-        @token = double("Token")
-      end
+      let(:token) { double("Token") }
       
       it "creates a connection with an oauth2 middleware" do
-        connection = subject.connection(token: @token)
+        connection = subject.connection(token: token)
         handler = connection.builder.handlers.first
-        handler.name.should == 'FaradayMiddleware::OAuth2'
-        handler.instance_variable_get(:@args).should == [@token]
+        
+        expect(handler.name).to eq('FaradayMiddleware::OAuth2')
+        expect(handler.instance_variable_get(:@args)).to eq([token])
       end
     end
   end

data/spec/vkontakte_api/authorization_spec.rb

@@ -18,35 +18,38 @@ describe VkontakteApi::Authorization do
     
     @client = double("OAuth2::Client instance", auth_code: @auth_code, implicit: @implicit, client_credentials: @client_credentials)
     OAuth2::Client.stub(:new).and_return(@client)
-    
-    @auth = Object.new
-    @auth.extend VkontakteApi::Authorization
   end
   
+  let(:auth) do
+    Object.new.tap do |object|
+      object.extend VkontakteApi::Authorization
+    end
+  end  
+  
   describe "#authorization_url" do
     before(:each) do
-      @auth.stub(:client).and_return(@client)
+      auth.stub(:client).and_return(@client)
     end
     
     context "with a site type" do
       it "returns a valid authorization url" do
-        @auth_code.should_receive(:authorize_url).with(redirect_uri: @redirect_uri)
-        @auth.authorization_url(type: :site).should == @url
+        expect(@auth_code).to receive(:authorize_url).with(redirect_uri: @redirect_uri)
+        expect(auth.authorization_url(type: :site)).to eq(@url)
       end
     end
     
     context "with a client type" do
       it "returns a valid authorization url" do
-        @implicit.should_receive(:authorize_url).with(redirect_uri: @redirect_uri)
-        @auth.authorization_url(type: :client).should == @url
+        expect(@implicit).to receive(:authorize_url).with(redirect_uri: @redirect_uri)
+        expect(auth.authorization_url(type: :client)).to eq(@url)
       end
     end
     
     context "given a redirect_uri" do
       it "prefers the given uri over VkontakteApi.redirect_uri" do
         redirect_uri = 'http://example.com/oauth/callback'
-        @auth_code.should_receive(:authorize_url).with(redirect_uri: redirect_uri)
-        @auth.authorization_url(redirect_uri: redirect_uri)
+        expect(@auth_code).to receive(:authorize_url).with(redirect_uri: redirect_uri)
+        auth.authorization_url(redirect_uri: redirect_uri)
       end
     end
     
@@ -55,9 +58,9 @@ describe VkontakteApi::Authorization do
         scope = double("Scope")
         flat_scope = double("Flat scope")
         
-        VkontakteApi::Utils.should_receive(:flatten_argument).with(scope).and_return(flat_scope)
-        @auth_code.should_receive(:authorize_url).with(redirect_uri: @redirect_uri, scope: flat_scope)
-        @auth.authorization_url(scope: scope)
+        expect(VkontakteApi::Utils).to receive(:flatten_argument).with(scope).and_return(flat_scope)
+        expect(@auth_code).to receive(:authorize_url).with(redirect_uri: @redirect_uri, scope: flat_scope)
+        auth.authorization_url(scope: scope)
       end
     end
   end
@@ -70,42 +73,42 @@ describe VkontakteApi::Authorization do
       end
       
       it "gets the token" do
-        @auth_code.should_receive(:get_token).with(@code, redirect_uri: @redirect_uri)
-        @auth.authorize(type: :site, code: @code)
+        expect(@auth_code).to receive(:get_token).with(@code, redirect_uri: @redirect_uri)
+        auth.authorize(type: :site, code: @code)
       end
     end
     
     context "with an app_server type" do
       it "gets the token" do
-        @client_credentials.should_receive(:get_token).with({ redirect_uri: @redirect_uri }, subject::OPTIONS[:client_credentials])
-        @auth.authorize(type: :app_server)
+        expect(@client_credentials).to receive(:get_token).with({ redirect_uri: @redirect_uri }, subject::OPTIONS[:client_credentials])
+        auth.authorize(type: :app_server)
       end
     end
     
     context "with an unknown type" do
       it "raises an ArgumentError" do
         expect {
-          @auth.authorize(type: :unknown)
+          auth.authorize(type: :unknown)
         }.to raise_error(ArgumentError)
       end
     end
     
     it "builds a VkontakteApi::Client instance with the received token" do
       client = double("VkontakteApi::Client instance")
-      VkontakteApi::Client.should_receive(:new).with(@token).and_return(client)
-      @auth.authorize.should == client
+      expect(VkontakteApi::Client).to receive(:new).with(@token).and_return(client)
+      expect(auth.authorize).to eq(client)
     end
   end
   
   describe "#client" do
     it "creates and returns an OAuth2::Client instance" do
-      OAuth2::Client.should_receive(:new).with(@app_id, @app_secret, subject::OPTIONS[:client])
-      @auth.send(:client).should == @client
+      expect(OAuth2::Client).to receive(:new).with(@app_id, @app_secret, subject::OPTIONS[:client])
+      expect(auth.send(:client)).to eq(@client)
     end
     
     it "caches the result" do
-      OAuth2::Client.should_receive(:new).once
-      5.times { @auth.send(:client) }
+      expect(OAuth2::Client).to receive(:new).once
+      5.times { auth.send(:client) }
     end
   end
 end