apis 0.4.1 → 0.5.0.pre1

data/README.md

@@ -1,43 +1,42 @@
 ## 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 = Apis::Connecton.new(:url => 'http://api.example.com') do
+      use Apis::Request::JSON
+      use Apis::Request::OAuth2
+      use Apis::Request::Logger
+      adapter Apis::Adapter::NetHTTP
+    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
+    connection.get('/hello')
+
+## Specification
 
-## Request Middleware
+### Middleware
 
-### Example
+Middleware is object that responds to `call`, accepts `env` hash and returns array
+with three elements in order: `status`, `headers`, `body`.
 
-		class Request::Middleware
-			def call(env)
-				env[:params][:token] = 'abcdef'
-			end
-		end
+Middleware should accept `application` it decorates as first parameter to initializer.
 
-### Description
+Example middleware:
 
-Basically, request middleware is an object that responds to `#call`.
-It will be initialized with args passed if any.
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+      
+      def call(env)
+        # do something with request
+        response = @app.call(env) # it's decorator, you are responsible to forward message to decorated app
+        # do something with response
+        response
+      end
+    end
 
 ### Environment
 
-* `:method` - HTTP method name
-* `:body` – body of request sent to server
-* `:headers` – headers hash
+* `:method` - uppercased request method, should be one of: `:GET`, `:POST`, `:PUT`, `:DELETE`
+* `:uri` - parsed URi, instance of `Addressable::URI`
+* `:params` - params to be sent, instance of `Hash`
+* `:body` - body to be sent. If set than `:params` are not used
+* `:headers` - headers to be sent, instance of `Hash`

data/Rakefile

@@ -1,4 +1,7 @@
 require 'bundler'
 require 'rspec/core/rake_task'
+
 Bundler::GemHelper.install_tasks
-RSpec::Core::RakeTask.new
+RSpec::Core::RakeTask.new do |rspec|
+  rspec.pattern = ENV['SPEC'] || 'spec/**/*_spec.rb'
+end

data/apis.gemspec

@@ -6,17 +6,17 @@ Gem::Specification.new do |s|
   s.name        = "apis"
   s.version     = Apis::VERSION
   s.platform    = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 1.9'
   s.authors     = ["Marjan Krekoten' (Мар'ян Крекотень)"]
-  s.email       = ["m@hmarynka.com"]
-  s.homepage    = "http://hmarynka.com/labs/apis"
+  s.email       = ["krekoten@gmail.com"]
+  s.homepage    = "https://github.com/krekoten/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.rubyforge_project = "[none]"
 
   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.test_files    = `git ls-files -- spec/*`.split("\n")
   s.require_paths = ["lib"]
 
   s.add_development_dependency 'rspec', '>= 2.5'

data/lib/apis/adapter/net_http.rb

@@ -2,19 +2,26 @@ require 'net/http'
 
 module Apis
   module Adapter
-    class NetHTTP < Abstract
-      def connection
-        Net::HTTP.start(uri.host, uri.port)
-      end
+    class NetHTTP
+      def call(env)
+        env[:url].path = '/' if env[:url].path.empty?
+        http = Net::HTTP.new(env[:url].host, env[:url].port)
+        query = Addressable::URI.new
+        query.query_values = env[:params]
+        response = case env[:method]
+        when :GET
+          http.get([env[:url].path, query.query].compact.join('?'), env[:headers])
+        when :HEAD
+          http.head([env[:url].path, query.query].compact.join('?'), env[:headers])
+        when :POST
+          http.post(env[:url].path, query.query, env[:headers])
+        when :PUT
+          http.put(env[:url].path, query.query, env[:headers])
+        when :DELETE
+          http.delete([env[:url].path, query.query].compact.join('?'), env[:headers])
+        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
+        [response.code.to_i, response, response.body]
       end
     end
   end

data/lib/apis/adapter/rack_test.rb

@@ -4,16 +4,7 @@ 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

@@ -1,76 +1,32 @@
 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)
+    def initialize(&block)
+      @handlers = []
+      @adapter = nil
+      instance_eval(&block) if block
     end
 
-    def replace(old, middleware)
-      if index = index(old)
-        insert(middleware, index)
-        remove(old)
+    def use(middleware, *args)
+      block = block_given? ? Proc.new : nil
+      @handlers << -> parent do
+        middleware.new(parent, *args, &block)
       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)
+    def adapter(middleware = nil, *args)
+      if middleware
+        block = block_given? ? Proc.new : nil
+        @adapter = nil
+      end
+      @adapter ||= -> do
+        (middleware || Apis::Adapter::NetHTTP).new(*args, &block)
       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
-        []
+      @handlers.reverse.inject(adapter.call) do |parent, handler|
+        handler.call(parent)
       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

@@ -1,96 +1,52 @@
-require 'addressable/uri'
+require 'fiber'
 
 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
+  class Request
+    attr_accessor :params, :headers
+    def initialize
+      @params, @headers = {}, {}
     end
+  end
 
-    def uri
-      @scope.uri
+  class Connection
+    attr_reader :uri
+    def initialize(options)
+      options.each do |key, value|
+        send("#{key}=", value) if respond_to?("#{key}=")
+      end
+      @builder = Builder.new(&(block_given? ? Proc.new : nil))
     end
 
     def uri=(value)
-      @scope.uri = Addressable::URI.parse(value)
-    end
-
-    def headers
-      @scope.headers
+      @uri = Addressable::URI.parse(value)
     end
 
-    def headers=(value)
-      @scope.headers.merge!(value)
-    end
+    def head(*args, &block)   make_request(:HEAD, *args, &block) end
 
-    def params
-      @scope.params
-    end
+    def get(*args, &block)    make_request(:GET, *args, &block) end
 
-    def params=(value)
-      @scope.params.merge!(value)
-    end
+    def post(*args, &block)   make_request(:POST, *args, &block) end
 
-    def request
-      block = block_given? ? Proc.new : nil
-      @request ||= Apis::Builder.new(:lookup_context => Apis::Middleware::Request, &block)
-      @request
-    end
+    def put(*args, &block)    make_request(:PUT, *args, &block) end
 
-    def response
-      block = block_given? ? Proc.new : nil
-      @response ||= Apis::Builder.new(:lookup_context => Apis::Middleware::Response, &block)
-      @response
-    end
+    def delete(*args, &block) make_request(:DELETE, *args, &block) end
 
-    def adapter(value = nil)
-      if Symbol === value
-        value = Apis::Adapter.lookup(value)
+    def make_request(method, uri = nil, params = {}, headers = {}, &block)
+      if block
+        request = Apis::Request.new
+        yield request
+        params.merge!(request.params)
+        headers.merge!(request.headers)
       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
+      Fiber.new do
+        @builder.to_app.call(
+          :method   => method,
+          :uri      => uri ? self.uri.join(uri) : self.uri,
+          :params   => params,
+          :headers  => headers
+        )
+      end.resume
     end
   end
 end

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

@@ -4,23 +4,19 @@ module Apis
   module Middleware
     module Response
       class Json
-        attr_accessor :app
-        def initialize(app = nil)
+        APPLICATION_JSON = 'application/json'
+        def initialize(app)
           @app = app
         end
 
         def call(env)
-          env.body = case env.body
-          when ''
-            nil
-          when 'true'
-            true
-          when 'false'
-            false
+          env[:headers]['Accept'] = APPLICATION_JSON
+          status, headers, body = @app.call(env)
+          if headers['Content-Type'] && headers['Content-Type'].include?(APPLICATION_JSON)
+            [status, headers, MultiJson.decode(body)]
           else
-            ::MultiJson.decode(env.body)
+            [status, headers, body]
           end
-          @app.call(env) if @app
         end
       end
     end

data/lib/apis/version.rb

@@ -1,3 +1,3 @@
 module Apis
-  VERSION = "0.4.1"
+  VERSION = "0.5.0.pre1"
 end

data/lib/apis.rb

@@ -1,55 +1,21 @@
 $: << lib_dir unless $:.include?(lib_dir = File.expand_path('..', __FILE__))
 
+require 'addressable/uri'
+
 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
+      autoload :Json,             'apis/middleware/response/json'
     end
   end
 end

data/spec/apis/adapter/net_http_spec.rb

@@ -9,37 +9,48 @@ describe Apis::Adapter::NetHTTP do
     stop_server
   end
 
-  [:get, :post, :put, :delete, :head].each do |method|
-    context method.to_s.upcase do
+  [:HEAD, :GET, :POST, :PUT, :DELETE].each do |method|
+    context method do
+      it "returns status" do
+        adapter = Apis::Adapter::NetHTTP.new
+        status, headers, body = adapter.call(
+          :method   => method,
+          :url      => Addressable::URI.parse(server_host),
+          :headers  => {}
+        )
+        status.should == 200
+      end
+
       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
+        adapter = Apis::Adapter::NetHTTP.new
+        status, headers, body = adapter.call(
+          :method   => method,
+          :url      => Addressable::URI.parse(server_host),
+          :headers  => {}
+        )
+        body.should == method.to_s
+      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
+        adapter = Apis::Adapter::NetHTTP.new
+        status, headers, body = adapter.call(
+          :method   => method,
+          :url      => Addressable::URI.parse(server_host),
+          :headers  => {}
+        )
+        headers['X-Requested-With-Method'].should == method.to_s
       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"}'
+        adapter = Apis::Adapter::NetHTTP.new
+        status, headers, body = adapter.call(
+          :method   => method,
+          :url      => Addressable::URI.parse(server_host).join(method.to_s.downcase),
+          :headers  => {},
+          :params   => {:test => 'params'}
+        )
+        headers['X-Sent-Params'].should == %|{"test"=>"params"}|
       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

@@ -14,44 +14,4 @@ class RackApp
 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/builder_spec.rb

@@ -1,100 +1,24 @@
 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
+  it 'builds appilcation stack' do
+    app = Apis::Builder.new do
       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)
+      adapter FakeAdapter
+    end.to_app
+    app.should be_instance_of(NewMiddleware)
+    app.app.should be_instance_of(RESTMiddleware)
+    app.app.app.should be_instance_of(FakeAdapter)
   end
 
-  it 'evals block passed to constructor' do
-    builder = Apis::Builder.new do
-      use Middleware
+  it 'uses default adapter if none specified' do
+    app = Apis::Builder.new do
       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.to_app
+    app.should be_instance_of(NewMiddleware)
+    app.app.should be_instance_of(RESTMiddleware)
+    app.app.app.should be_instance_of(Apis::Adapter::NetHTTP)
   end
 end

data/spec/apis/connection_spec.rb

@@ -1,230 +1,52 @@
 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
+  let(:connection) do
+    Apis::Connection.new(:uri => 'http://api.example.com/') do
+      use EnvCheck
     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'}
+  context "on request" do
+    [:head, :get, :post, :put, :delete].each do |method|
+      it "sets env[:method] to :#{method.to_s.upcase} on #{method}" do
+        connection.send(method)
+        EnvCheck.env[:method].should == method.to_s.upcase.to_sym
       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
+    it "sets env[:uri] to Addressable::URI object initialized with URL" do
+      connection.get
+      EnvCheck.env[:uri].should == Addressable::URI.parse('http://api.example.com/')
     end
-  end
 
-  context 'performing request' do
-    before do
-      @connection = Apis::Connection.new(:uri => server_host) do
-        adapter FakeAdapter
-      end
+    it "merges uri passed to connection with uri passed to request" do
+      connection.get('users/1')
+      EnvCheck.env[:uri].should == Addressable::URI.parse('http://api.example.com/users/1')
     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
+    it "sets env[:params] to params hash passed to request" do
+      connection.get(nil, :param => 'test')
+      EnvCheck.env[:params].should == {:param => 'test'}
     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 == {}
+    it "sets env[:params] to params passed in block" do
+      connection.get do |request|
+        request.params[:param] = 'test'
       end
+      EnvCheck.env[:params].should == {:param => 'test'}
     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 "sets env[:headers] to headers hash passed to request" do
+      connection.get(nil, {}, {'Content-Type' => 'text/xml'})
+      EnvCheck.env[:headers].should == {'Content-Type' => 'text/xml'}
+    end
 
-      it 'calls midleware' do
-        response = @connection.get
-        response.body.should == 'altered'
+    it "sets env[:headers] to headers passed in block" do
+      connection.get do |request|
+        request.headers['Content-Type'] = 'text/xml'
       end
+      EnvCheck.env[:headers].should == {'Content-Type' => 'text/xml'}
     end
   end
 end

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

@@ -1,19 +1,27 @@
 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}
+  it "calls decorated application" do
+    middleware = double('middleware')
+    middleware.should_receive(:call).and_return([200, {}, ''])
+    Apis::Middleware::Response::Json.new(middleware).call({:headers => {}})
   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)
+  it "adds accept header" do
+    middleware = -> env do
+      env[:headers]['Accept'].should == 'application/json'
+      [200, {'Content-Type' => 'application/json'}, %|{"user":{"name":"User","age":25}}|]
+    end
+    Apis::Middleware::Response::Json.new(middleware).call({:headers => {}})
   end
-end
+
+  it 'parses body when content-type matches' do
+    middleware = -> env do
+      [200, {'Content-Type' => 'application/json'}, %|{"user":{"name":"User","age":25}}|]
+    end
+    status, headers, body = Apis::Middleware::Response::Json.new(middleware).call(:headers => {})
+    status.should == 200
+    headers.should == {'Content-Type' => 'application/json'}
+    body.should == {'user' => {'name' => 'User', 'age' => 25}}
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,17 @@
 require File.expand_path('../../lib/apis', __FILE__)
 
+class EnvCheck
+  class << self
+    attr_accessor :env
+    def call(env)
+      @env = env
+    end
+    def new(*args)
+      self
+    end
+  end
+end
+
 class BaseMiddleware
   attr_accessor :app
   def initialize(app)
@@ -28,6 +40,9 @@ class FakeAdapter < Apis::Adapter::Abstract
     @last_method, @last_path, @last_params, @last_headers = method, path, params, headers
     [200, {}, 'body']
   end
+
+  def call(env)
+  end
 end
 
 module DirHelper

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: apis
 version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.4.1
+  prerelease: 6
+  version: 0.5.0.pre1
 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)"
@@ -10,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-07 00:00:00 +03:00
-default_executable: 
+date: 2011-04-11 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -92,7 +91,7 @@ dependencies:
   version_requirements: *id007
 description: Rack-like HTTP client library inspired by Faraday done my way
 email: 
-- m@hmarynka.com
+- krekoten@gmail.com
 executables: []
 
 extensions: []
@@ -112,13 +111,10 @@ files:
 - 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
@@ -126,8 +122,7 @@ files:
 - spec/quality_spec.rb
 - spec/spec_helper.rb
 - spec/test_app.ru
-has_rdoc: true
-homepage: http://hmarynka.com/labs/apis
+homepage: https://github.com/krekoten/apis
 licenses: []
 
 post_install_message: 
@@ -140,24 +135,23 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: "0"
+      version: "1.9"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      version: "0"
+      version: 1.3.1
 requirements: []
 
-rubyforge_project: apis
-rubygems_version: 1.6.2
+rubyforge_project: "[none]"
+rubygems_version: 1.7.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

data/lib/apis/connection_scope.rb

@@ -1,27 +0,0 @@
-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/response.rb

@@ -1,25 +0,0 @@
-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/spec/apis/adapter_spec.rb

@@ -1,12 +0,0 @@
-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