vkontakte_api 0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+# Specify your gem's dependencies in vkontakte_api.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Vsevolod Romashov
+
+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/README.md

@@ -0,0 +1,95 @@
+# vkontakte_api
+
+`vkontakte_api` is a Ruby wrapper for VKontakte API. It allows you to call all API methods in the simplest possible way.
+
+Below is the English version of the readme. Russian version is located [here](https://github.com/7even/vkontakte_api/blob/master/README.ru.md).
+
+## Installation
+
+``` bash
+gem install vkontakte_api
+```
+
+## Usage
+
+Default HTTP request library is `Net::HTTP`. You can set any other adapter supported by `faraday` in the configure block like so:
+
+``` ruby
+VkontakteApi.configure do |config|
+  config.adapter = :net_http
+end
+```
+
+All requests are sent via `VkontakteApi::Client` instance. To create one you just pass an access token.
+
+``` ruby
+@app = VkontakteApi::Client.new('my_access_token')
+```
+
+Probably the easiest way to get an access token in a web-app is using [OmniAuth](https://github.com/intridea/omniauth), but you can roll your own authentication if for some reason `OmniAuth` isn't acceptable. Currently `vkontakte_api` doesn't offer authentication functionality.
+
+Now you can call the API methods. All method names are underscore_cased as opposed to the [official documentation](http://vk.com/developers.php?oid=-17680044&p=API_Method_Description) where they are camelCased, so `getGroups` becomes `get_groups`. You can still call them in a camelCased manner, but that is not a Ruby-way practice.
+
+``` ruby
+@app.get_user_settings  # => 327710
+@app.groups.get         # => [1, 31022447]
+```
+
+Predicate methods (those which begin with `is`, like `is_app_user`) are expected to return the result of some condition, so the '?' is appended to the end of the method name, and they return `true` or `false`:
+
+``` ruby
+@app.is_app_user? # => true
+```
+
+You can still call these without a '?' and get `'1'` or `'0'` in result if you want to handle that yourself.
+
+Now for parameters. All method parameters are named, and you can pass them in a hash where parameter names are keys and parameter values are values:
+
+``` ruby
+@app.friends.get(fields: 'uid,first_name,last_name')
+# => [
+  {
+    :uid          => "1",
+    :first_name   => "Павел",
+    :last_name    => "Дуров"
+  },
+  {
+    :uid          => "6492",
+    :first_name   => "Andrew",
+    :last_name    => "Rogozov"
+  }
+]
+```
+
+It's also worth noting that all returned hashes have symbolized keys.
+
+If the response is an Enumerable, you can pass a block that will yield each successive element and put the result in the returned array (like `Enumerable#map` does):
+
+``` ruby
+@app.friends.get(fields: 'first_name,last_name') do |friend|
+  "#{friend[:first_name]} #{friend[:last_name]}"
+end
+# => ["Павел Дуров", "Andrew Rogozov"]
+```
+
+`vkontakte_api` doesn't keep any method names list inside (except method namespaces like `friends` or `groups`) - when you call a method, it's name is camelcased before sending a request to VKontakte. So when a new method is added to the API, you don't need to wait for the new version of `vkontakte_api` gem - you can use that new method immediately. If you mistype the method name or use a method you don't have rights to call, you will get an exception with a relevant message (more about the exceptions below).
+
+### Error handling
+
+If VKontakte returns an error in response, you get a `VkontakteApi::Error` exception with all meaningful information that can be retrieved:
+
+``` ruby
+@app.audio.get_by_id
+# => VkontakteApi::Error: VKontakte returned an error 1: 'Unknown error occured' after calling method 'audio.getById' with parameters {}.
+```
+
+## Roadmap
+
+* Authentication (getting the access_token from VK)
+* RDoc coverage
+
+## Contributing
+
+If you want to contribute to the project, fork the repository, push your changes to a topic branch and send me a pull request.
+
+`vkontakte_api` is tested under MRI `1.8.7`, `1.9.2` and `1.9.3`. If something is working incorrectly or not working at all in one of these environments, this should be considered a bug. Any bug reports are welcome at Github issues.

data/README.ru.md

@@ -0,0 +1,95 @@
+# vkontakte_api
+
+`vkontakte_api` - ruby-обертка для API ВКонтакте. Она позволяет вызывать методы API настолько просто, насколько это возможно.
+
+Это русская версия readme. Английская версия лежит [здесь](https://github.com/7even/vkontakte_api/blob/master/README.md).
+
+## Установка
+
+``` bash
+gem install vkontakte_api
+```
+
+## Использование
+
+По умолчанию для HTTP-запросов используется `Net::HTTP`. Можно выбрать любой другой адаптер, поддерживаемый `faraday`, в блоке `VkontakteApi.configure` следующим образом:
+
+``` ruby
+VkontakteApi.configure do |config|
+  config.adapter = :net_http
+end
+```
+
+Все запросы к API отправляются через объект класса `VkontakteApi::Client`. Чтобы создать его, нужно просто передать в конструктор токен доступа.
+
+``` ruby
+@app = VkontakteApi::Client.new('my_access_token')
+```
+
+Пожалуй, самый простой способ получить токен в веб-приложении - использовать [OmniAuth](https://github.com/intridea/omniauth), но если это неприемлемо, можно реализовать свой механизм авторизации. На данный момент `vkontakte_api` не умеет получать токен.
+
+Теперь можно вызывать методы API. Все названия методов переведены в underscore_case - в отличие от [официальной документации](http://vk.com/developers.php?oid=-17680044&p=API_Method_Description), где они в camelCase, т.е. `getGroups` становится `get_groups`. Можно по прежнему писать методы в camelCase, но это не соответствует стандартам стиля кода, принятым в ruby.
+
+``` ruby
+@app.get_user_settings  # => 327710
+@app.groups.get         # => [1, 31022447]
+```
+
+Предикатные методы (названия которых начинаются с `is`, например `is_app_user`) должны возвращать результат какого-то условия, поэтому в конец названия метода добавляется '?', и возвращается булево значение (`true` или `false`):
+
+``` ruby
+@app.is_app_user? # => true
+```
+
+Можно вызывать эти методы и без '?' на конце, тогда они будут возвращать `'0'` или `'1'`.
+
+Теперь о параметрах. Все параметры именованные, и передаются в методы в виде хэша, где ключи соответствуют названиям параметров, а значения - соответственно, их значениям:
+
+``` ruby
+@app.friends.get(fields: 'uid,first_name,last_name')
+# => [
+  {
+    :uid          => "1",
+    :first_name   => "Павел",
+    :last_name    => "Дуров"
+  },
+  {
+    :uid          => "6492",
+    :first_name   => "Andrew",
+    :last_name    => "Rogozov"
+  }
+]
+```
+
+Также следует заметить, что все возвращаемые хэши имеют символьные ключи.
+
+Если результат метода - Enumerable, то методу можно передать блок, который будет вызван для каждого элемента результата. В этом случае метод вернет массив из результатов выполнения блока с каждым элементом (аналогично `Enumerable#map`):
+
+``` ruby
+@app.friends.get(fields: 'first_name,last_name') do |friend|
+  "#{friend[:first_name]} #{friend[:last_name]}"
+end
+# => ["Павел Дуров", "Andrew Rogozov"]
+```
+
+`vkontakte_api` не содержит списка названий методов (если не считать пространств имен, вроде `friends` или `groups`) - когда вызывается метод, его название переводится в camelCase, а уже потом отправляется запрос к ВКонтакте. Поэтому когда новый метод добавляется в API, не нужно ждать новой версии гема `vkontakte_api` - можно использовать этот новый метод сразу же. Если в названии запрошенного метода допущены ошибки, или вызван метод, на выполнение которого отсутствуют права, будет выброшено исключение с соответствующим сообщением (об исключениях чуть ниже).
+
+### Обработка ошибок
+
+Если ВКонтакте возвращает ошибку, выбрасывается исключение класса `VkontakteApi::Error` со всей значимой информацией, которую можно получить:
+
+``` ruby
+@app.audio.get_by_id
+# => VkontakteApi::Error: VKontakte returned an error 1: 'Unknown error occured' after calling method 'audio.getById' with parameters {}.
+```
+
+## Планы
+
+* Авторизация (получение токена доступа с ВКонтакте)
+* Документация RDoc
+
+## Участие в разработке
+
+Если вы хотите поучаствовать в разработке проекта, форкните репозиторий, положите свои изменения в отдельную ветку и отправьте мне pull request.
+
+`vkontakte_api` тестируется под MRI `1.8.7`, `1.9.2` и `1.9.3`. Если в одной из этих сред что-то работает неправильно, либо вообще не работает, то это следует считать багом, и написать об этом в issues на Github.

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+
+desc 'Fires up the console with preloaded vkontakte_api'
+task :console do
+  sh 'pry -I ./lib/ -r ./lib/vkontakte_api.rb'
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = '--color --format doc'
+end
+
+task :default => :spec

data/lib/vkontakte_api.rb

@@ -0,0 +1,19 @@
+require 'faraday'
+require 'yajl'
+require 'yaml'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/object/to_query'
+
+require 'vkontakte_api/version'
+require 'vkontakte_api/error'
+require 'vkontakte_api/configuration'
+require 'vkontakte_api/api'
+require 'vkontakte_api/resolver'
+require 'vkontakte_api/client'
+
+module VkontakteApi
+  extend VkontakteApi::Configuration
+end
+
+# short alias
+VK = VkontakteApi unless defined?(VK)

data/lib/vkontakte_api/api.rb

@@ -0,0 +1,28 @@
+module VkontakteApi
+  module API
+    BASE_HOST = 'https://api.vkontakte.ru'
+    BASE_URL  = '/method/'
+    
+    class << self
+      def call(method_name, args = {}, &block)
+        connection = Faraday.new(:url => BASE_HOST) do |builder|
+          builder.adapter(VkontakteApi.adapter)
+        end
+        
+        url = url_for(method_name, args)
+        body = connection.get(url).body
+        response = Yajl::Parser.parse(body, :symbolize_keys => true)
+        
+        if response.has_key?(:error)
+          raise VkontakteApi::Error.new(response[:error])
+        else
+          response[:response]
+        end
+      end
+    private
+      def url_for(method_name, args)
+        "#{BASE_URL}#{method_name}?#{args.to_param}"
+      end
+    end
+  end
+end

data/lib/vkontakte_api/client.rb

@@ -0,0 +1,18 @@
+module VkontakteApi
+  class Client
+    attr_reader :access_token
+    
+    def initialize(access_token = nil)
+      @access_token = access_token
+    end
+    
+    def authorized?
+      !@access_token.nil?
+    end
+    
+    def method_missing(method_name, *args, &block)
+      args = args.first || {}
+      VkontakteApi::Resolver.new(:access_token => @access_token).send(method_name, args, &block)
+    end
+  end
+end

data/lib/vkontakte_api/configuration.rb

@@ -0,0 +1,22 @@
+module VkontakteApi
+  module Configuration
+    OPTION_NAMES = [:app_id, :app_secret, :adapter]
+    
+    attr_accessor *OPTION_NAMES
+    
+    DEFAULT_ADAPTER = :net_http
+    
+    def configure
+      yield self if block_given?
+      self
+    end
+    
+    def reset
+      @adapter = DEFAULT_ADAPTER
+    end
+    
+    def self.extended(base)
+      base.reset
+    end
+  end
+end

data/lib/vkontakte_api/error.rb

@@ -0,0 +1,27 @@
+module VkontakteApi
+  class Error < StandardError
+    def initialize(data)
+      @error_code = data.delete(:error_code)
+      @error_msg  = data.delete(:error_msg)
+      @params     = {}
+      
+      request_params = parse_params(data.delete :request_params)
+      
+      @method_name  = request_params.delete('method')
+      @access_token = request_params.delete('access_token')
+      @oauth        = request_params.delete('oauth')
+      @params       = request_params
+    end
+    
+    def message
+      "VKontakte returned an error #{@error_code}: \'#{@error_msg}\' after calling method \'#{@method_name}\' with parameters #{@params.inspect}."
+    end
+  private
+    def parse_params(params)
+      params.inject({}) do |memo, pair|
+        memo[pair[:key]] = pair[:value]
+        memo
+      end
+    end
+  end
+end

data/lib/vkontakte_api/namespaces.yml

@@ -0,0 +1,22 @@
+- friends
+- groups
+- photos
+- wall
+- newsfeed
+- notifications
+- audio
+- video
+- docs
+- places
+- secure
+- storage
+- notes
+- pages
+- activity
+- offers
+- questions
+- subscriptions
+- messages
+- likes
+- status
+- polls

data/lib/vkontakte_api/resolver.rb

@@ -0,0 +1,91 @@
+module VkontakteApi
+  class Resolver
+    PREDICATE_NAMES = /^(is.*)\?$/
+    
+    attr_reader :namespace
+    
+    def initialize(options = {})
+      @namespace    = options.delete(:namespace)
+      @access_token = options.delete(:access_token)
+    end
+    
+    def method_missing(method_name, *args, &block)
+      method_name = method_name.to_s
+      
+      if Resolver.namespaces.include?(method_name)
+        # method with a two-level name called
+        Resolver.new(:namespace => method_name, :access_token => @access_token)
+      else
+        # method with a one-level name called
+        name, type = Resolver.vk_method_name(method_name, @namespace)
+        
+        # adding access_token to the args hash
+        args = args.first || {}
+        args.update(:access_token => @access_token)
+        
+        result = API.call(name, args, &block)
+        
+        if result.respond_to?(:each)
+          # enumerable result receives :map with a block when called with a block
+          # or is returned untouched otherwise
+          block_given? ? result.map(&block) : result
+        else
+          # non-enumerable result is typecasted
+          # (and yielded if block_given?)
+          result = typecast(result, type)
+          block_given? ? yield(result) : result
+        end
+      end
+    end
+  private
+    def typecast(parameter, type)
+      case type
+      when :boolean
+        # '1' becomes true, '0' becomes false
+        !parameter.to_i.zero?
+      else
+        parameter
+      end
+    end
+    
+    class << self
+      attr_reader :namespaces
+      
+      # load namespaces array from namespaces.yml
+      def load_namespaces
+        filename    = File.expand_path('../namespaces.yml', __FILE__)
+        file        = File.read(filename)
+        @namespaces = YAML.load(file)
+      end
+      
+      # vk_method_name('get_country_by_id', 'places')
+      # => 'places.getCountryById'
+      def vk_method_name(method_name, namespace = nil)
+        method_name = method_name.to_s
+        
+        if method_name =~ PREDICATE_NAMES
+          # predicate methods should return true or false
+          method_name.sub!(PREDICATE_NAMES, '\1')
+          type = :boolean
+        else
+          # other methods can return anything they want
+          type = :anything
+        end
+        
+        full_name = ''
+        full_name << convert(namespace) + '.' unless namespace.nil?
+        full_name << convert(method_name)
+        
+        [full_name, type]
+      end
+    private
+      # convert('get_profiles')
+      # => 'getProfiles'
+      def convert(name)
+        name.camelize(:lower)
+      end
+    end
+  end
+end
+
+VkontakteApi::Resolver.load_namespaces

data/lib/vkontakte_api/version.rb

@@ -0,0 +1,3 @@
+module VkontakteApi
+  VERSION = '0.1'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'vkontakte_api'
+require 'pry'

data/spec/vkontakte_api/api_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe VkontakteApi::API do
+  before(:each) do
+    @method_name =  'apiMethod'
+    @args = {
+      :field        => 'value',
+      :access_token => 'some_token'
+    }
+  end
+  
+  describe ".call" do
+    before(:each) do
+      @url = stub("URL")
+      VkontakteApi::API.stub(:url_for).and_return(@url)
+      
+      @connection = stub("Faraday connection")
+      Faraday.stub(:new).and_return(@connection)
+      
+      body = stub("Response body")
+      response = stub("Response", :body => body)
+      @connection.stub(:get).and_return(response)
+      
+      @result = stub("Result")
+      @result.stub(:has_key?) do |key|
+        if key == 'response'
+          true
+        else
+          false
+        end
+      end
+      
+      @result_response  = stub("Result[response]")
+      @result_error     = stub("Result[error]").as_null_object
+      
+      @result.stub(:[]) do |key|
+        if key == :response
+          @result_response
+        else
+          @result_error
+        end
+      end
+      
+      Yajl::Parser.stub(:parse).and_return(@result)
+    end
+    
+    it "calls the url from .url_for" do
+      @connection.should_receive(:get).with(@url)
+      VkontakteApi::API.call('apiMethod')
+    end
+    
+    context "with a successful response" do
+      it "returns the response body" do
+        VkontakteApi::API.call('apiMethod').should == @result_response
+      end
+    end
+    
+    context "with an error response" do
+      before(:each) do
+        @result.stub(:has_key?) do |key|
+          if key == 'response'
+            false
+          else
+            true
+          end
+        end
+      end
+      
+      it "raises a VkontakteApi::Error" do
+        expect {
+          VkontakteApi::API.call('apiMethod')
+        }.to raise_error(VkontakteApi::Error)
+      end
+    end
+  end
+  
+  describe ".url_for" do
+    it "constructs a valid VK API url" do
+      url = VkontakteApi::API.send(:url_for, @method_name, @args)
+      url.should == '/method/apiMethod?access_token=some_token&field=value'
+    end
+  end
+end

data/spec/vkontakte_api/client_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe VkontakteApi::Client do
+  before(:each) do
+    @token = stub("Access token")
+  end
+  
+  describe "#initialize" do
+    context "without arguments" do
+      it "creates a client with a nil access_token" do
+        VkontakteApi::Client.new.access_token.should be_nil
+      end
+    end
+    
+    context "with a token argument" do
+      it "creates a client with a given access_token" do
+        client = VkontakteApi::Client.new(@token)
+        client.access_token.should == @token
+      end
+    end
+  end
+  
+  describe "#authorized?" do
+    context "with an unauthorized client" do
+      it "returns false" do
+        VkontakteApi::Client.new.should_not be_authorized
+      end
+    end
+    
+    context "with an authorized client" do
+      it "returns true" do
+        VkontakteApi::Client.new(@token).should be_authorized
+      end
+    end
+  end
+  
+  describe "#method_missing" do
+    before(:each) do
+      @resolver = stub("Resolver").as_null_object
+      VkontakteApi::Resolver.stub(:new).and_return(@resolver)
+      @args = {:field => 'value'}
+    end
+    
+    it "creates a resolver, passing it the access_token" do
+      VkontakteApi::Resolver.should_receive(:new).with(:access_token => @token)
+      VkontakteApi::Client.new(@token).api_method(@args)
+    end
+    
+    it "delegates to VkontakteApi::Resolver" do
+      @resolver.should_receive(:api_method).with(@args)
+      VkontakteApi::Client.new(@token).api_method(@args)
+    end
+  end
+end

data/spec/vkontakte_api/configuration_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+class Configurable
+  extend VkontakteApi::Configuration
+end
+
+describe VkontakteApi::Configuration do
+  describe "#configure" do
+    it "yields self" do
+      Configurable.should_receive(:some_method)
+      Configurable.configure do |config|
+        config.some_method
+      end
+    end
+    
+    it "returns self" do
+      Configurable.configure.should == Configurable
+    end
+  end
+  
+  describe "#reset" do
+    it "sets all options to their default values" do
+      Configurable.reset
+      Configurable.app_id.should be_nil
+      Configurable.app_secret.should be_nil
+      Configurable.adapter.should == VkontakteApi::Configuration::DEFAULT_ADAPTER
+    end
+  end
+end

data/spec/vkontakte_api/error_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe VkontakteApi::Error do
+  before(:each) do
+    @e = VkontakteApi::Error.new(
+      :error_code      => 5,
+      :error_msg       => 'User authorization failed: invalid access_token.',
+      :request_params  => [
+        {
+          :key   => 'oauth',
+          :value => '1'
+        },
+        {
+          :key   => 'method',
+          :value => 'unknownMethod'
+        },
+        {
+          :key   => 'some',
+          :value => 'params'
+        },
+        {
+          :key   => 'access_token',
+          :value => '123'
+        }
+      ]
+    )
+  end
+  
+  describe "#message" do
+    it "returns all needed data about an error" do
+      message = 'VKontakte returned an error 5: \'User authorization failed: invalid access_token.\' after calling method \'unknownMethod\' with parameters {"some"=>"params"}.'
+      expect {
+        raise @e
+      }.to raise_error(@e.class, message)
+    end
+  end
+end

data/spec/vkontakte_api/resolver_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe VkontakteApi::Resolver do
+  describe "#method_missing" do
+    before(:each) do
+      @result = stub("API result")
+      @result.stub(:respond_to?).and_return(false)
+      
+      VkontakteApi::API.stub(:call).and_return(@result)
+      @args = {:arg_name => 'arg_value'}
+      @token = stub("Access token")
+    end
+    
+    context "with a nil @namespace" do
+      before(:each) do
+        @resolver = VkontakteApi::Resolver.new(:access_token => @token)
+      end
+      
+      context "with method_name not from NAMESPACES" do
+        before(:each) do
+          VkontakteApi::Resolver.stub(:vk_method_name).and_return(['apiMethod', :anything])
+        end
+        
+        it "calls #vk_method_name with method name and nil namespace" do
+          VkontakteApi::Resolver.should_receive(:vk_method_name).with('api_method', nil)
+          @resolver.api_method
+        end
+        
+        it "calls #api_call with full VK method name" do
+          full_args = @args.merge(:access_token => @token)
+          VkontakteApi::API.should_receive(:call).with('apiMethod', full_args)
+          @resolver.api_method(@args).should == @result
+        end
+      end
+      
+      context "with method_name from NAMESPACES" do
+        it "return a new resolver with the corresponding @namespace" do
+          new_resolver = @resolver.friends
+          new_resolver.should be_a(VkontakteApi::Resolver)
+          new_resolver.namespace.should == 'friends'
+        end
+      end
+    end
+    
+    context "with a non-nil @namespace" do
+      before(:each) do
+        @resolver = VkontakteApi::Resolver.new(:namespace => 'friends')
+        VkontakteApi::Resolver.stub(:vk_method_name).and_return('friends.apiMethod')
+      end
+      
+      it "calls #vk_method_name with method name and @namespace" do
+        VkontakteApi::Resolver.should_receive(:vk_method_name).with('api_method', 'friends')
+        @resolver.api_method
+      end
+    end
+    
+    context "with a non-enumerable result" do
+      before(:each) do
+        @resolver = VkontakteApi::Resolver.new
+        
+        @type = stub("Type")
+        VkontakteApi::Resolver.stub(:vk_method_name).and_return([:method_name, @type])
+        
+        @typecasted_value = stub("Typecasted value")
+        @resolver.stub(:typecast).and_return(@typecasted_value)
+      end
+      
+      it "returns #typecast-ed value" do
+        @resolver.should_receive(:typecast).with(@result, @type).and_return(@typecasted_value)
+        @resolver.method_name.should == @typecasted_value
+      end
+      
+      context "when block_given?" do
+        it "yields the #typecast-ed value and returns the result of the block" do
+          block_result = stub("Block result")
+          @typecasted_value.should_receive(:result_method).and_return(block_result)
+          
+          @resolver.api_method do |result|
+            result.result_method
+          end.should == block_result
+        end
+      end
+    end
+    
+    context "with an enumerable result" do
+      before(:each) do
+        @resolver = VkontakteApi::Resolver.new
+        
+        @element1 = stub("First element")
+        @element2 = stub("Second element")
+        @enumerable_result = [@element1, @element2]
+        VkontakteApi::API.stub(:call).and_return(@enumerable_result)
+      end
+      
+      it "returns the untouched value" do
+        @resolver.method_name.should == @enumerable_result
+      end
+      
+      context "when block_given?" do
+        it "yields each element untouched to the block" do
+          result1 = stub("First element after result_method")
+          result2 = stub("Second element after result_method")
+          @element1.should_receive(:result_method).and_return(result1)
+          @element2.should_receive(:result_method).and_return(result2)
+          
+          @resolver.api_method do |result|
+            result.result_method
+          end.should == [result1, result2]
+        end
+      end
+    end
+  end
+  
+  describe ".vk_method_name" do
+    context "with a usual method name" do
+      context "without a namespace" do
+        it "returns 'methodName'" do
+          VkontakteApi::Resolver.vk_method_name(:api_method).first.should == 'apiMethod'
+        end
+      end
+      
+      context "with a namespace" do
+        it "returns 'namespace.methodName'" do
+          VkontakteApi::Resolver.vk_method_name(:api_method, 'namespace').first.should == 'namespace.apiMethod'
+        end
+      end
+      
+      it "returns :anything as a type" do
+        VkontakteApi::Resolver.vk_method_name(:api_method).last.should == :anything
+      end
+    end
+    
+    context "with a predicate method name" do
+      it "returns method name without '?'" do
+        VkontakteApi::Resolver.vk_method_name(:is_it_working?).first.should == 'isItWorking'
+      end
+      
+      it "returns :boolean as a type" do
+        VkontakteApi::Resolver.vk_method_name(:is_it_working?).last.should == :boolean
+      end
+    end
+  end
+  
+  describe "#typecast" do
+    before(:each) do
+      @resolver = VkontakteApi::Resolver.new
+    end
+    
+    context "with an :anything type" do
+      it "returns it's argument untouched" do
+        @resolver.send(:typecast, :some_arg, :anything).should == :some_arg
+      end
+    end
+    
+    context "with a :boolean type" do
+      context "and zero result" do
+        it "returns false" do
+          @resolver.send(:typecast, '0', :boolean).should == false
+        end
+      end
+      
+      context "and non-zero parameter" do
+        it "returns true" do
+          @resolver.send(:typecast, '1', :boolean).should == true
+        end
+      end
+    end
+  end
+end

data/spec/vkontakte_api_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe VkontakteApi do
+  describe ".configure" do
+    VkontakteApi::Configuration::OPTION_NAMES.each do |name|
+      it "should set the #{name}" do
+        VkontakteApi.configure do |config|
+          config.send("#{name}=", name)
+          VkontakteApi.send(name).should == name
+        end
+      end
+    end
+  end
+end

data/vkontakte_api.gemspec

@@ -0,0 +1,28 @@
+# encoding: utf-8
+$: << File.expand_path('../lib', __FILE__)
+require 'vkontakte_api/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'vkontakte_api'
+  s.version     = VkontakteApi::VERSION
+  s.authors     = ['Vsevolod Romashov']
+  s.email       = ['7@7vn.ru']
+  s.homepage    = ''
+  s.summary     = %q{Ruby-way wrapper for VKontakte API}
+  s.description = %q{A transparent wrapper for API of vk.com social network called VKontakte. Supports ruby-way method naming (without any method lists inside), result typecasting and any faraday-supported http adapter of your choice (no hardcoded Net::HTTP).}
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+  
+  s.add_runtime_dependency 'activesupport', '~> 3.0'
+  s.add_runtime_dependency 'i18n',          '~> 0.6'
+  s.add_runtime_dependency 'faraday',       '~> 0.7.6'
+  s.add_runtime_dependency 'yajl-ruby',     '~> 1.0'
+  
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'awesome_print'
+end

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: vkontakte_api
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Vsevolod Romashov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70258037639260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70258037639260
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &70258037638480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70258037638480
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: &70258037637640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *70258037637640
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: &70258037636920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70258037636920
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70258037656820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70258037656820
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70258037656180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70258037656180
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &70258037655480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70258037655480
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: &70258037654980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70258037654980
+description: A transparent wrapper for API of vk.com social network called VKontakte.
+  Supports ruby-way method naming (without any method lists inside), result typecasting
+  and any faraday-supported http adapter of your choice (no hardcoded Net::HTTP).
+email:
+- 7@7vn.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.md
+- README.ru.md
+- Rakefile
+- lib/vkontakte_api.rb
+- lib/vkontakte_api/api.rb
+- lib/vkontakte_api/client.rb
+- lib/vkontakte_api/configuration.rb
+- lib/vkontakte_api/error.rb
+- lib/vkontakte_api/namespaces.yml
+- lib/vkontakte_api/resolver.rb
+- lib/vkontakte_api/version.rb
+- spec/spec_helper.rb
+- spec/vkontakte_api/api_spec.rb
+- spec/vkontakte_api/client_spec.rb
+- spec/vkontakte_api/configuration_spec.rb
+- spec/vkontakte_api/error_spec.rb
+- spec/vkontakte_api/resolver_spec.rb
+- spec/vkontakte_api_spec.rb
+- vkontakte_api.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2826215231838222847
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2826215231838222847
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Ruby-way wrapper for VKontakte API
+test_files:
+- spec/spec_helper.rb
+- spec/vkontakte_api/api_spec.rb
+- spec/vkontakte_api/client_spec.rb
+- spec/vkontakte_api/configuration_spec.rb
+- spec/vkontakte_api/error_spec.rb
+- spec/vkontakte_api/resolver_spec.rb
+- spec/vkontakte_api_spec.rb