apis 0.4.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.yardoc
+doc
+.DS_Store

data/.yardopts

@@ -0,0 +1 @@
+-m markdown

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in apis.gemspec
+gemspec
+
+gem 'rack-test', :require => 'rack/test'
+gem 'yajl-ruby', :require => 'yajl'

data/README.md

@@ -0,0 +1,43 @@
+## Usage
+
+		connection = Apis::Connecton.new(:url => 'http://api.example.com') do
+			request do
+				use Apis::Request::JSON			# |
+				use Apis::Request::OAuth2		# |
+				use Apis::Request::Logger		# \/
+			end
+			adapter :net_http					# -->
+			response do
+				use Apis::Response::JSON		# |
+				use Apis::Response::Logger		# \/
+			end
+		end
+		
+		connection.get('/hello')
+		
+		connection.request.replace Apis::Request::OAuth2, Apis::Request::OAuth
+		
+		connection.post('/post_with_oauth_10') do |request|
+			request.params = {:q => 'm'}
+		end
+
+## Request Middleware
+
+### Example
+
+		class Request::Middleware
+			def call(env)
+				env[:params][:token] = 'abcdef'
+			end
+		end
+
+### Description
+
+Basically, request middleware is an object that responds to `#call`.
+It will be initialized with args passed if any.
+
+### Environment
+
+* `:method` - HTTP method name
+* `:body` – body of request sent to server
+* `:headers` – headers hash

data/Rakefile

@@ -0,0 +1,4 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+Bundler::GemHelper.install_tasks
+RSpec::Core::RakeTask.new

data/apis.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "apis/version"
+
+Gem::Specification.new do |s|
+  s.name        = "apis"
+  s.version     = Apis::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Marjan Krekoten' (Мар'ян Крекотень)"]
+  s.email       = ["m@hmarynka.com"]
+  s.homepage    = "http://hmarynka.com/labs/apis"
+  s.summary     = %q{Working bee of API wrapper}
+  s.description = %q{Rack-like HTTP client library inspired by Faraday done my way}
+
+  s.rubyforge_project = "apis"
+
+  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_development_dependency 'rspec', '>= 2.5'
+  s.add_development_dependency 'sinatra'
+  s.add_development_dependency 'rack-test'
+  s.add_development_dependency 'unicorn'
+
+  # Middlewares
+  s.add_development_dependency 'multi_json'
+  s.add_development_dependency 'yajl-ruby'
+
+  s.add_dependency 'addressable'
+end

data/lib/apis.rb

@@ -0,0 +1,55 @@
+$: << lib_dir unless $:.include?(lib_dir = File.expand_path('..', __FILE__))
+
+module Apis
+  class DuplicateMiddleware < StandardError; end
+  autoload :Connection,       'apis/connection'
+  autoload :ConnectionScope,  'apis/connection_scope'
+  autoload :Builder,          'apis/builder'
+  autoload :Response,         'apis/response'
+
+  module Registerable
+    def register(symbol, klass)
+      @lookup_table ||= {}
+      @lookup_table[symbol] = klass
+    end
+
+    def lookup(symbol)
+      @lookup_table ||= {}
+      self.const_get(@lookup_table[symbol])
+    end
+  end
+
+  module Adapter
+    autoload :Abstract,         'apis/adapter/abstract'
+    autoload :NetHTTP,          'apis/adapter/net_http'
+    autoload :RackTest,         'apis/adapter/rack_test'
+
+    extend Registerable
+
+    class << self
+      # Default connection adapter
+      # You can change it by assignin new value 
+      def default
+        @default ||= :net_http
+      end
+      attr_writer :default
+    end
+
+    register :net_http, :NetHTTP
+    register :rack_test, :RackTest
+  end
+
+  module Middleware
+    module Request
+      extend Registerable
+    end
+
+    module Response
+      autoload :Json,           'apis/middleware/response/json'
+
+      extend Registerable
+
+      register :json, :Json
+    end
+  end
+end

data/lib/apis/adapter/abstract.rb

@@ -0,0 +1,27 @@
+module Apis
+  module Adapter
+    class Abstract
+      class NotImplemented < StandardError; end
+
+      attr_accessor :uri
+
+      def initialize(options = {})
+        options.each do |key, value|
+          send("#{key}=", value) if respond_to?("#{key}=")
+        end
+      end
+
+      # Performs request to resource
+      #
+      # @param [Symbol, String] method HTTP method to perform
+      # @param [String] path Relative path to resource host
+      # @param [Hash] params Params to be sent
+      # @param [Hash] headers Headers to be sent
+      #
+      # @return [Array] headers, body
+      def run(method, path, params = {}, headers = {})
+        raise Apis::Adapter::Abstract::NotImplemented
+      end
+    end
+  end
+end

data/lib/apis/adapter/net_http.rb

@@ -0,0 +1,21 @@
+require 'net/http'
+
+module Apis
+  module Adapter
+    class NetHTTP < Abstract
+      def connection
+        Net::HTTP.start(uri.host, uri.port)
+      end
+
+      def run(method, path, params = {}, headers = {})
+        _module = Net::HTTP.const_get(method.to_s.capitalize)
+        request = _module.new(path)
+        response = connection.request(
+          request,
+          params.empty? ? nil : Addressable::URI.new.tap { |uri| uri.query_values = params }.query
+        )
+        [response.code.to_i] + response
+      end
+    end
+  end
+end

data/lib/apis/adapter/rack_test.rb

@@ -0,0 +1,19 @@
+require 'rack/test'
+
+module Apis
+  module Adapter
+    class RackTest < Abstract
+      include Rack::Test::Methods
+
+      attr_accessor :app
+
+      attr_reader :last_path, :last_params, :last_headers
+
+      def run(method, path, params = {}, headers = {})
+        @last_path, @last_params, @last_headers = path, params, headers
+        send(method, path, params, headers)
+        [last_response.status, last_response.headers, last_response.body]
+      end
+    end
+  end
+end

data/lib/apis/builder.rb

@@ -0,0 +1,76 @@
+module Apis
+  class Builder
+    attr_accessor :lookup_context
+    def initialize(options = {}, &block)
+      options.each do |key, value|
+        send("#{key}=", value) if respond_to?("#{key}=")
+      end
+      @stack = []
+      @mapping = {}
+      block_eval(&block) if block
+    end
+
+    def use(middleware)
+      insert(middleware)
+    end
+
+    def replace(old, middleware)
+      if index = index(old)
+        insert(middleware, index)
+        remove(old)
+      end
+    end
+
+    def insert(middleware, index = nil)
+      middleware = lookup_middleware(middleware)
+      raise Apis::DuplicateMiddleware, "#{middleware} already in stack" if include?(middleware)
+      index ||= @stack.length
+      @stack[index] = lambda do |parent|
+        middleware.new(parent)
+      end
+      @mapping[middleware] = index
+    end
+
+    def remove(middleware)
+      middleware = lookup_middleware(middleware)
+      @stack.delete_at(@mapping.delete(middleware))
+    end
+
+    def index(middleware)
+      middleware = lookup_middleware(middleware)
+      @mapping[middleware]
+    end
+
+    def length
+      @stack.length
+    end
+
+    def include?(middleware)
+      !!index(middleware)
+    end
+
+    def to_a
+      @mapping.to_a.sort { |a, b| a.last <=> b.last}.map { |e| e.first }
+    end
+    alias to_ary to_s
+
+    def to_app
+      unless @stack.empty?
+        inner_app = @stack.last.call(nil)
+        @stack.reverse[1..-1].inject(inner_app) { |parent, lazy| lazy.call(parent) }
+      else
+        []
+      end
+    end
+
+    def block_eval(&block)
+      instance_eval(&block)
+    end
+
+    def lookup_middleware(middleware)
+      @lookup_context && !(Class === middleware) ?
+        @lookup_context.lookup(middleware) :
+        middleware
+    end
+  end
+end

data/lib/apis/connection.rb

@@ -0,0 +1,96 @@
+require 'addressable/uri'
+
+module Apis
+  class Connection
+    def initialize(options = {})
+      @scope = Apis::ConnectionScope.new
+      @scope.headers, @scope.params = {}, {}
+
+      if String === options
+        self.uri = options
+      else
+        options.each do |key, value|
+          send("#{key}=", value) if respond_to?("#{key}=")
+        end
+      end
+
+      if block_given?
+        block = Proc.new
+        instance_eval(&block)
+      end
+      adapter(Apis::Adapter.default) unless @adapter
+    end
+
+    def uri
+      @scope.uri
+    end
+
+    def uri=(value)
+      @scope.uri = Addressable::URI.parse(value)
+    end
+
+    def headers
+      @scope.headers
+    end
+
+    def headers=(value)
+      @scope.headers.merge!(value)
+    end
+
+    def params
+      @scope.params
+    end
+
+    def params=(value)
+      @scope.params.merge!(value)
+    end
+
+    def request
+      block = block_given? ? Proc.new : nil
+      @request ||= Apis::Builder.new(:lookup_context => Apis::Middleware::Request, &block)
+      @request
+    end
+
+    def response
+      block = block_given? ? Proc.new : nil
+      @response ||= Apis::Builder.new(:lookup_context => Apis::Middleware::Response, &block)
+      @response
+    end
+
+    def adapter(value = nil)
+      if Symbol === value
+        value = Apis::Adapter.lookup(value)
+      end
+
+      @adapter = value.new(:uri => uri) if value
+      @adapter
+    end
+
+    [:get, :head, :post, :put, :delete].each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(path = nil, params = {}, headers = {})
+          run_request(#{method.inspect}, path, params, headers, &(block_given? ? Proc.new : nil))
+        end
+      RUBY
+    end
+
+    def run_request(method, path = nil, params = {}, headers = {}, &block)
+      #block = block_given? ? Proc.new : nil
+      # TODO: refactor this, it's ugly
+      @scope.scoped do
+        self.params = params if params
+        self.headers = headers if headers
+        block.call(self) if block
+        path ||= uri.path.empty? ? '/' : uri.path
+        self.request.to_app.call(
+          :method => method,
+          :params => self.params,
+          :headers => self.headers
+        ) unless self.request.to_a.empty?
+        res = Apis::Response.new(*adapter.run(method, path, self.params, self.headers))
+        self.response.to_app.call(res) unless self.response.to_a.empty?
+        res
+      end
+    end
+  end
+end

data/lib/apis/connection_scope.rb

@@ -0,0 +1,27 @@
+module Apis
+  class ConnectionScope
+    def initialize
+      @data = {}
+    end
+
+    def method_missing(method, value = nil)
+      if method =~ /\=$/ && value
+        @data[method.to_s.gsub(/\=/, '').to_sym] = value
+      else
+        @data[method]
+      end
+    end
+
+    def scoped
+      backup = {}
+      @data.each do |key, value|
+        backup[key] = value.dup
+      end
+      yield
+    ensure
+      backup.each do |key, value|
+        @data[key] = value
+      end
+    end
+  end
+end

data/lib/apis/middleware/response/json.rb

@@ -0,0 +1,28 @@
+require 'multi_json'
+
+module Apis
+  module Middleware
+    module Response
+      class Json
+        attr_accessor :app
+        def initialize(app = nil)
+          @app = app
+        end
+
+        def call(env)
+          env.body = case env.body
+          when ''
+            nil
+          when 'true'
+            true
+          when 'false'
+            false
+          else
+            ::MultiJson.decode(env.body)
+          end
+          @app.call(env) if @app
+        end
+      end
+    end
+  end
+end

data/lib/apis/response.rb

@@ -0,0 +1,25 @@
+module Apis
+  class Response
+    attr_accessor :status, :headers, :body
+    def initialize(status, headers, body)
+      @status, @headers, @body = status, headers, body
+    end
+
+    def to_env
+      {:status => status, :headers => headers, :body => body}
+    end
+
+    def to_a
+      [status, headers, body]
+    end
+    alias to_ary to_a
+
+    def [](key)
+      respond_to?(key) ? send(key) : nil
+    end
+
+    def []=(key, value)
+      send("#{key}=", value) if respond_to?("#{key}=")
+    end
+  end
+end

data/lib/apis/version.rb

@@ -0,0 +1,3 @@
+module Apis
+  VERSION = "0.4.1"
+end

data/spec/apis/adapter/net_http_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'addressable/uri'
+
+describe Apis::Adapter::NetHTTP do
+  before(:all) do
+    start_server
+  end
+  after(:all) do
+    stop_server
+  end
+
+  [:get, :post, :put, :delete, :head].each do |method|
+    context method.to_s.upcase do
+      it "returns body" do
+        adapter = Apis::Adapter::NetHTTP.new(:uri => Addressable::URI.parse(server_host))
+        status, headers, body = adapter.run(method, '/')
+        body.should == method.to_s.upcase
+      end unless method == :head
+
+      it "returns headers" do
+        adapter = Apis::Adapter::NetHTTP.new(:uri => Addressable::URI.parse(server_host))
+        status, headers, body = adapter.run(method, '/')
+        headers['X-Requested-With-Method'].should == method.to_s.upcase
+      end
+
+      it "returns status" do
+        adapter = Apis::Adapter::NetHTTP.new(:uri => Addressable::URI.parse(server_host))
+        status, headers, body = adapter.run(method, '/')
+        status.should == 200
+      end
+
+      it "sends params" do
+        adapter = Apis::Adapter::NetHTTP.new(:uri => Addressable::URI.parse(server_host))
+        status, headers, body = adapter.run(method, "/#{method}", {:param => 'value'})
+        headers['X-Sent-Params'].should == '{"param"=>"value"}'
+      end
+    end
+  end
+
+  it 'registered under :net_http' do
+    Apis::Connection.new do
+      adapter :net_http
+    end.adapter.should be_instance_of(Apis::Adapter::NetHTTP)
+  end
+end

data/spec/apis/adapter/rack_test_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+class RackApp
+  def call(env)
+    [
+      200,
+      {
+        'X-Request-Method' => env['REQUEST_METHOD'],
+        'X-Request-At' => env['PATH_INFO']
+      },
+      env['REQUEST_METHOD'] == 'HEAD' ? [] : [env['REQUEST_METHOD']]
+    ]
+  end
+end
+
+describe Apis::Adapter::RackTest do
+  [:get, :post, :put, :delete, :head].each do |method|
+    context method.to_s.upcase do
+      let(:adapter) { Apis::Adapter::RackTest.new(:app => RackApp.new) }
+      it "returns body" do
+        status, headers, body = adapter.run(method, '/')
+        body.should == method.to_s.upcase
+      end unless method == :head
+
+      it "returns headers" do
+        status, headers, body = adapter.run(method, '/')
+        headers['X-Request-Method'].should == method.to_s.upcase
+      end
+
+      it "returns status" do
+        status, headers, body = adapter.run(method, '/')
+        status.should == 200
+      end
+
+      it 'saves passed path' do
+        adapter.run(method, "/#{method}")
+        adapter.last_path.should == "/#{method}"
+      end
+
+      it 'saves passed params' do
+        adapter.run(method, '/', {:test => 'param'})
+        adapter.last_params.should == {:test => 'param'}
+      end
+
+      it 'saves passed headers' do
+        adapter.run(method, '/', {}, {'Content-Type' => 'text'})
+        adapter.last_headers.should == {'Content-Type' => 'text'}
+      end
+    end
+  end
+
+  it 'registered under :rack_test' do
+    Apis::Connection.new do
+      adapter :rack_test
+    end.adapter.should be_instance_of(Apis::Adapter::RackTest)
+  end
+end

data/spec/apis/adapter_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Apis::Adapter do
+  it 'registers adapters shortnames' do
+    Apis::Adapter.register(:fake, :FakeAdapter)
+    Apis::Adapter.lookup(:fake).should == FakeAdapter
+  end
+
+  specify ':net_http is set as default adapter' do
+    Apis::Adapter.default.should == :net_http
+  end
+end

data/spec/apis/builder_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Apis::Builder do
+  it 'adds middleware to stack' do
+    builder = Apis::Builder.new
+    builder.use Middleware
+    builder.length.should == 1
+  end
+
+  it 'raises error when duplicate middleware added' do
+    builder = Apis::Builder.new
+    builder.use Middleware
+    expect { builder.use Middleware }.to raise_error(Apis::DuplicateMiddleware, 'Middleware already in stack')
+  end
+
+  it 'shows if middleware in stack' do
+    builder = Apis::Builder.new
+    builder.use Middleware
+    builder.include?(Middleware).should == true
+  end
+
+  it 'replaces middleware with another' do
+    builder = Apis::Builder.new
+    builder.use Middleware
+    builder.use RESTMiddleware
+    builder.replace Middleware, NewMiddleware
+    builder.include?(Middleware).should == false
+    builder.include?(NewMiddleware).should == true
+    builder.to_a.should == [NewMiddleware, RESTMiddleware]
+  end
+
+  it 'removes middleware from stack' do
+    builder = Apis::Builder.new
+    builder.use Middleware
+    builder.include?(Middleware).should == true
+    builder.remove(Middleware)
+    builder.include?(Middleware).should == false
+  end
+
+  it 'returns stacked middlewares in order' do
+    builder = Apis::Builder.new
+    builder.use Middleware
+    builder.use NewMiddleware
+    builder.use RESTMiddleware
+    app = builder.to_app
+    app.should be_instance_of(Middleware)
+    app.app.should be_instance_of(NewMiddleware)
+    app.app.app.should be_instance_of(RESTMiddleware)
+  end
+
+  it 'evals block' do
+    builder = Apis::Builder.new
+    builder.block_eval do |builder|
+      use Middleware
+      use NewMiddleware
+      use RESTMiddleware
+    end
+
+    app = builder.to_app
+    app.should be_instance_of(Middleware)
+    app.app.should be_instance_of(NewMiddleware)
+    app.app.app.should be_instance_of(RESTMiddleware)
+  end
+
+  it 'evals block passed to constructor' do
+    builder = Apis::Builder.new do
+      use Middleware
+      use NewMiddleware
+      use RESTMiddleware
+    end
+
+    app = builder.to_app
+    app.should be_instance_of(Middleware)
+    app.app.should be_instance_of(NewMiddleware)
+    app.app.app.should be_instance_of(RESTMiddleware)
+  end
+
+  it 'inserts middleware only once' do
+    builder = Apis::Builder.new do
+      use Middleware
+    end
+
+    app = builder.to_app
+    app.should be_instance_of(Middleware)
+    app.app.should be_nil
+  end
+
+  it 'lookups middleware by shortcut if lookup object givven' do
+    Lookup = Module.new do
+      extend Apis::Registerable
+    end
+    Lookup.register(:middleware, :Middleware)
+    builder = Apis::Builder.new(:lookup_context => Lookup) do
+      use :middleware
+    end
+
+    app = builder.to_app
+    app.should be_instance_of(Middleware)
+  end
+end

data/spec/apis/connection_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+
+describe Apis::Connection do
+  context 'configuration' do
+    context 'options' do
+      it 'sets url' do
+        Apis::Connection.new(:uri => 'http://api.example.org').uri.should == Addressable::URI.parse('http://api.example.org')
+      end
+
+      it 'sets url if it is only parameter' do
+        Apis::Connection.new('http://api.example.org').uri.should == Addressable::URI.parse('http://api.example.org')
+      end
+
+      it 'sets headers' do
+        Apis::Connection.new(
+          :headers => {
+            'Content-Type' => 'text',
+            'User-Agent' => 'apis'
+          }
+        ).headers.should == {
+          'Content-Type' => 'text',
+          'User-Agent' => 'apis'
+        }
+      end
+
+      it 'sets params' do
+        Apis::Connection.new(
+          :params => {:q => 'apis', :hl => 'uk'}
+        ).params.should == {:q => 'apis', :hl => 'uk'}
+      end
+    end
+
+    context 'methods' do
+      let(:connection) { Apis::Connection.new }
+      it 'sets url' do
+        connection.uri = 'http://api.example.org'
+        connection.uri.should == Addressable::URI.parse('http://api.example.org')
+      end
+
+      it 'sets headers' do
+        connection.headers = {
+          'Content-Type' => 'text',
+          'User-Agent' => 'apis'
+        }
+        connection.headers.should == {
+          'Content-Type' => 'text',
+          'User-Agent' => 'apis'
+        }
+      end
+
+      it 'sets params' do
+        connection.params = {:q => 'apis', :hl => 'uk'}
+        connection.params.should == {:q => 'apis', :hl => 'uk'}
+      end
+
+      it 'updates headers' do
+        connection.headers = {'Content-Type' => 'text'}
+        connection.headers = {'User-Agent' => 'apis'}
+        connection.headers.should == {
+          'Content-Type' => 'text',
+          'User-Agent' => 'apis'
+        }
+      end
+
+      it 'updates params' do
+        connection.params = {:q => 'apis'}
+        connection.params = {:hl => 'uk'}
+        connection.params.should == {:q => 'apis', :hl => 'uk'}
+      end
+    end
+
+    context 'stack building' do
+      it 'constructs request stack' do
+        connection = Apis::Connection.new do
+          request do
+            use Middleware
+            use NewMiddleware
+            use RESTMiddleware
+          end
+        end
+
+        connection.request.to_a.should == [Middleware, NewMiddleware, RESTMiddleware]
+      end
+
+      it 'constructs response stack' do
+        connection = Apis::Connection.new do
+          response do
+            use Middleware
+            use NewMiddleware
+            use RESTMiddleware
+          end
+        end
+
+        connection.response.to_a.should == [Middleware, NewMiddleware, RESTMiddleware]
+      end
+
+      it 'sets adapter' do
+        connection = Apis::Connection.new do
+          adapter FakeAdapter
+        end
+        connection.adapter.should be_instance_of(FakeAdapter)
+      end
+
+      it 'finds adapter using symbol shortcut' do
+        Apis::Adapter.register(:fake, :FakeAdapter)
+        connection = Apis::Connection.new do
+          adapter :fake
+        end
+        connection.adapter.should be_instance_of(FakeAdapter)
+      end
+
+      it 'uses default adapter if none specified' do
+        connection = Apis::Connection.new
+        connection.adapter nil
+        connection.adapter.should be_instance_of(Apis::Adapter::NetHTTP)
+      end
+    end
+  end
+
+  context 'performing request' do
+    before do
+      @connection = Apis::Connection.new(:uri => server_host) do
+        adapter FakeAdapter
+      end
+    end
+
+    [:get, :head, :post, :put, :delete].each do |method|
+      context method.to_s.upcase do
+        it 'passes method to adapter' do
+          @connection.send(method)
+          @connection.adapter.last_method.should == method
+        end
+
+        it 'passes path to adapter' do
+          @connection.send(method, "/#{method}")
+          @connection.adapter.last_path.should == "/#{method}"
+        end
+
+        it 'passes query params to adapter' do
+          @connection.send(method, "/#{method}", {:q => 'text'})
+          @connection.adapter.last_params.should == {:q => 'text'}
+        end
+
+        it 'passes params specified in block' do
+          @connection.send(method, "/#{method}") do |request|
+            request.params = {:test => 'params'}
+          end
+          @connection.adapter.last_params.should == {:test => 'params'}
+        end
+
+        it 'doesn\'t not overwrite params of connection' do
+          @connection.params = {:q => 'test'}
+          @connection.send(method, "/#{method}") do |request|
+            request.params = {:test => 'params'}
+          end
+          @connection.adapter.last_params.should == {:q => 'test', :test => 'params'}
+          @connection.params.should == {:q => 'test'}
+        end
+
+        it 'merges connection params with method params' do
+          @connection.params = {:test => 'param'}
+          @connection.send(method, "/#{method}", {:q => 'text'})
+          @connection.adapter.last_params.should == {:q => 'text', :test => 'param'}
+        end
+
+        it 'passes headers to adapter' do
+          @connection.send(method, "/#{method}", {}, {'Content-Type' => 'text'})
+          @connection.adapter.last_headers.should == {'Content-Type' => 'text'}
+        end
+
+        it 'merges connection headers with method headers' do
+          @connection.headers = {'User-Agent' => 'apis'}
+          @connection.send(method, "/#{method}", {}, {'Content-Type' => 'text'})
+          @connection.adapter.last_headers.should == {'Content-Type' => 'text', 'User-Agent' => 'apis'}
+        end
+
+        it 'doesn\'t overwrite headers of connection' do
+          @connection.headers = {:q => 'test'}
+          @connection.send(method, "/#{method}") do |request|
+            request.headers = {:test => 'params'}
+          end
+          @connection.adapter.last_headers.should == {:q => 'test', :test => 'params'}
+          @connection.headers.should == {:q => 'test'}
+        end
+      end
+    end
+  end
+
+  context 'request with middleware' do
+    context 'request middleware' do
+      before do
+        Apis::Middleware::Request.register(:middleware, :Middleware)
+        @connection = Apis::Connection.new(:uri => server_host) do
+          request do
+            use :middleware
+          end
+          adapter FakeAdapter
+        end
+      end
+
+      it 'calls midleware' do
+        @connection.get
+        @connection.adapter.last_headers.should == {'Middleware' => 'true'}
+      end
+
+      it "doesn't overwrite headers of connection" do
+        @connection.get
+        @connection.adapter.last_headers.should == {'Middleware' => 'true'}
+        @connection.headers.should == {}
+      end
+    end
+
+    context 'response midleware' do
+      before do
+        Apis::Middleware::Response.register(:res, :Response)
+        @connection = Apis::Connection.new(:uri => server_host) do
+          adapter FakeAdapter
+          response do
+            use :res
+          end
+        end
+      end
+
+      it 'calls midleware' do
+        response = @connection.get
+        response.body.should == 'altered'
+      end
+    end
+  end
+end

data/spec/apis/middleware/response/json_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Apis::Middleware::Response::Json do
+  it 'replaces body with parsed data' do
+    MultiJson.engine = :yajl
+    json = Apis::Middleware::Response::Json.new
+    request = Apis::Response.new(200, {}, %|{"name":"Marjan Krekoten'","age": 23}|)
+    json.call(request)
+    request.body.should == {"name" => "Marjan Krekoten'", "age" => 23}
+  end
+
+  it 'registered under :json' do
+    Apis::Connection.new do
+      response do
+        use :json
+      end
+    end.response.to_a.should include(Apis::Middleware::Response::Json)
+  end
+end

data/spec/apis_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Apis do
+end

data/spec/quality_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+describe "The library itself" do
+  def check_for_tab_characters(filename)
+    failing_lines = []
+    File.readlines(filename).each_with_index do |line,number|
+      failing_lines << number + 1 if line =~ /\t/
+    end
+
+    unless failing_lines.empty?
+      "#{filename} has tab characters on lines #{failing_lines.join(', ')}"
+    end
+  end
+
+  def check_for_extra_spaces(filename)
+    failing_lines = []
+    File.readlines(filename).each_with_index do |line,number|
+      next if line =~ /^\s+#.*\s+\n$/
+      failing_lines << number + 1 if line =~ /\s+\n$/
+    end
+
+    unless failing_lines.empty?
+      "#{filename} has spaces on the EOL on lines #{failing_lines.join(', ')}"
+    end
+  end
+
+  RSpec::Matchers.define :be_well_formed do
+    failure_message_for_should do |actual|
+      actual.join("\n")
+    end
+
+    match do |actual|
+      actual.empty?
+    end
+  end
+
+  it "has no malformed whitespace" do
+    error_messages = []
+    Dir.chdir(File.expand_path("../..", __FILE__)) do
+      `git ls-files`.split("\n").each do |filename|
+        next if filename =~ /\.gitmodules|fixtures|\.md/
+        error_messages << check_for_tab_characters(filename)
+        error_messages << check_for_extra_spaces(filename)
+      end
+    end
+    error_messages.compact.should be_well_formed
+  end
+
+  it "can still be built" do
+    Dir.chdir(root) do
+      `gem build apis.gemspec`
+      $?.should == 0
+      `rm apis-*.gem`
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,60 @@
+require File.expand_path('../../lib/apis', __FILE__)
+
+class BaseMiddleware
+  attr_accessor :app
+  def initialize(app)
+    @app = app
+  end
+end
+class Middleware < BaseMiddleware
+  def call(env)
+    env[:params][:middleware] = 'true'
+    env[:headers]['Middleware'] = 'true'
+    @app.call(env) if @app
+  end
+end
+NewMiddleware = Class.new(BaseMiddleware)
+RESTMiddleware = Class.new(BaseMiddleware)
+
+class Response < BaseMiddleware
+  def call(env)
+    env[:body] = 'altered'
+  end
+end
+
+class FakeAdapter < Apis::Adapter::Abstract
+  attr_accessor :last_method, :last_path, :last_params, :last_headers
+  def run(method, path = nil, params = {}, headers = {})
+    @last_method, @last_path, @last_params, @last_headers = method, path, params, headers
+    [200, {}, 'body']
+  end
+end
+
+module DirHelper
+  def root
+    @root ||= File.expand_path('../..', __FILE__)
+  end
+end
+
+module SinatraHelper
+  def server_port
+    1234
+  end
+
+  def server_host
+    "http://localhost:#{server_port}"
+  end
+
+  def start_server
+    %x{unicorn -p #{server_port} #{root}/spec/test_app.ru -D -P #{root}/spec/uni.pid} # 3&> /dev/null
+  end
+
+  def stop_server
+    %x{kill `cat #{root}/spec/uni.pid`}
+  end
+end
+
+RSpec.configure do |rspec|
+  rspec.include DirHelper
+  rspec.include SinatraHelper
+end

data/spec/test_app.ru

@@ -0,0 +1,16 @@
+require 'sinatra'
+
+[:head, :get, :post, :put, :delete].each do |method|
+  send(method, '/') do
+    headers['X-Requested-With-Method'] = method.to_s.upcase
+    "#{method.to_s.upcase}" unless method == :head
+  end
+
+  send(method, "/#{method}") do
+    headers['X-Requested-With-Method'] = method.to_s.upcase
+    headers['X-Sent-Params'] = params.inspect
+    "#{method.to_s.upcase}" unless method == :head
+  end
+end
+
+run Sinatra::Application

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification 
+name: apis
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.4.1
+platform: ruby
+authors: 
+- "Marjan Krekoten' (\xD0\x9C\xD0\xB0\xD1\x80'\xD1\x8F\xD0\xBD \xD0\x9A\xD1\x80\xD0\xB5\xD0\xBA\xD0\xBE\xD1\x82\xD0\xB5\xD0\xBD\xD1\x8C)"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-07 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.5"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: unicorn
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: multi_json
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: addressable
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id007
+description: Rack-like HTTP client library inspired by Faraday done my way
+email: 
+- m@hmarynka.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .yardopts
+- Gemfile
+- README.md
+- Rakefile
+- apis.gemspec
+- lib/apis.rb
+- lib/apis/adapter/abstract.rb
+- lib/apis/adapter/net_http.rb
+- lib/apis/adapter/rack_test.rb
+- lib/apis/builder.rb
+- lib/apis/connection.rb
+- lib/apis/connection_scope.rb
+- lib/apis/middleware/response/json.rb
+- lib/apis/response.rb
+- lib/apis/version.rb
+- spec/apis/adapter/net_http_spec.rb
+- spec/apis/adapter/rack_test_spec.rb
+- spec/apis/adapter_spec.rb
+- spec/apis/builder_spec.rb
+- spec/apis/connection_spec.rb
+- spec/apis/middleware/response/json_spec.rb
+- spec/apis_spec.rb
+- spec/quality_spec.rb
+- spec/spec_helper.rb
+- spec/test_app.ru
+has_rdoc: true
+homepage: http://hmarynka.com/labs/apis
+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"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: apis
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Working bee of API wrapper
+test_files: 
+- spec/apis/adapter/net_http_spec.rb
+- spec/apis/adapter/rack_test_spec.rb
+- spec/apis/adapter_spec.rb
+- spec/apis/builder_spec.rb
+- spec/apis/connection_spec.rb
+- spec/apis/middleware/response/json_spec.rb
+- spec/apis_spec.rb
+- spec/quality_spec.rb
+- spec/spec_helper.rb
+- spec/test_app.ru