picky 4.0.0pre1 → 4.0.0pre2

data/lib/picky/sources/delicious.rb

@@ -1,63 +0,0 @@
-module Picky
-
-  module Sources
-
-    # Describes a Delicious (http://deli.cio.us) source.
-    #
-    # This source has a fixed set of categories:
-    # * title
-    # * tags
-    # * url
-    #
-    # Examples:
-    #  Sources::CSV.new('usrnam', 'paswrd')
-    #
-    class Delicious < Base
-
-      def initialize username, password
-        check_gem
-        @username = username
-        @password = password
-      end
-      def check_gem # :nodoc:
-        require 'www/delicious'
-      rescue LoadError
-        warn_gem_missing 'www-delicious', 'the delicious source'
-        exit 1
-      end
-
-      def to_s
-        "#{self.class.name}(#{@username})"
-      end
-
-      # Harvests the data to index.
-      #
-      def harvest category
-        get_data do |indexed_id, data|
-          text = data[category.from]
-          next unless text
-          yield indexed_id, text
-        end
-      end
-
-      #
-      #
-      def get_data # :nodoc:
-        @generated_id ||= 0
-        @posts ||= WWW::Delicious.new(@username, @password).posts_recent(count: 100)
-        @posts.each do |post|
-          data = {
-            title: post.title,
-            tags:  post.tags.join(' '),
-            url:   post.url.to_s
-          }
-          @generated_id += 1
-          yield @generated_id, data
-        end
-      end
-
-    end
-
-  end
-
-end

data/lib/picky/sources/mongo.rb

@@ -1,80 +0,0 @@
-module Picky
-
-  module Sources
-
-    # Important note: We're not sure if this works already.
-    #
-    # A Mongo database source.
-    #
-    # Options:
-    # * url, db
-    # Example:
-    #   Sources::Mongo.new(:collection1, :collection2, :url => 'localhost:28017', :db => 'testdatabase')
-  	# Be sure to escape the URL properly, e.g. # => %23 in the databasename if needed
-  	#
-    # and all the options of a <tt>RestClient::Resource</tt>.
-    # See http://github.com/archiloque/rest-client.
-    #
-    class Mongo < Base
-
-      # Raised when a Mongo source is instantiated without a valid uri.
-    	#
-    	# Important!
-      # You have to start your mongodb with --rest in order to use
-      # the rest / http interface
-    	#
-      class NoDBGiven < StandardError; end
-
-  		@@id_key = '_id'
-      #
-      #
-      def initialize *category_names, options
-        check_gem
-
-  			unless options[:url] && options[:db]
-  				raise_no_db_given(category_names)
-  			end
-
-  		  @db         = RestClient::Resource.new options.delete(:url), options
-  			@database   = options.delete(:db)
-  		  @key_format = options[:key_format] && options[:key_format].intern || :to_s
-  		end
-
-      # Tries to require the rest_client gem.
-      #
-      def check_gem # :nodoc:
-        require 'rest_client'
-      rescue LoadError
-        warn_gem_missing 'rest-client', 'the MongoDB source'
-        exit 1
-      end
-
-  		# Fetches the data, @limit=0 will return all records
-  		#
-  		# Limit is set to 0 by default - all collection entries will be send
-  		# If want to limit the results, set to to any other number, e.g. limit=15
-  		# to return only 15 entries
-  		#
-  		def harvest category
-  			collection = (category.from || category.index_name).to_s
-  			resp = @db["/#{@database}/#{category.index_name}/?@limit=0"].get
-  			JSON.parse(resp)['rows'].each do |row|
-  			  text = row[collection].to_s
-  			  next unless text
-  				index_key = row.delete @@id_key # Note: I removed .values
-  				yield index_key, text
-  			end
-  		end
-
-      def raise_no_db_given category_names # :nodoc:
-        raise NoDBGiven.new(category_names.join(', '))
-      end
-
-      def to_s
-        self.class.name
-      end
-
-    end
-  end
-
-end

data/lib/picky/wrappers/category/location.rb

@@ -1,38 +0,0 @@
-module Picky
-  module Wrappers
-    module Category
-
-      module Location
-
-        # THINK Is this the best way to do this?
-        #
-        def self.wrap category, grid, precision = 1, anchor = 0.0
-          wrapped_exact = Wrappers::Bundle::Location.new category.exact, grid: grid, precision: precision, anchor: anchor
-
-          category.class_eval do
-
-            # Uses a basic tokenizer.
-            #
-            def tokenizer
-              @tokenizer ||= Tokenizer.new
-            end
-
-            # Both use the exact index.
-            #
-            # TODO Necessary to wrap?
-            #
-            define_method :exact do
-              wrapped_exact
-            end
-            define_method :partial do
-              wrapped_exact
-            end
-
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/lib/tasks/routes.rake

@@ -1,8 +0,0 @@
-# Routing tasks.
-#
-desc "Shows the available URL paths."
-task :routes => :application do
-  Picky::Application.apps.each do |app|
-    puts app.to_routes
-  end
-end

data/spec/lib/adapters/rack/base_spec.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-#
-require 'spec_helper'
-
-describe Picky::Adapters::Rack::Base do
-  
-  before(:each) do
-    @adapter = described_class.new
-  end
-  
-  describe 'respond_with' do
-    describe 'by default' do
-      it 'uses json' do
-        @adapter.respond_with('response').should ==
-          [200, { 'Content-Type' => 'application/json', 'Content-Length' => '8' }, ['response']]
-      end
-    end
-    it 'adapts the content length' do
-      @adapter.respond_with('123').should ==
-        [200, { 'Content-Type' => 'application/json', 'Content-Length' => '3' }, ['123']]
-    end
-  end
-  
-end

data/spec/lib/adapters/rack/live_parameters_spec.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-#
-require 'spec_helper'
-
-describe Picky::Adapters::Rack::LiveParameters do
-
-  let(:live_parameters) { stub :live_parameters }
-  let(:adapter) { described_class.new live_parameters }
-
-  describe 'to_app' do
-    it 'works' do
-      lambda { adapter.to_app }.should_not raise_error
-    end
-    it 'returns the right thing' do
-      adapter.to_app.should respond_to(:call)
-    end
-    it 'returned lambda should call parameters on the live parameters' do
-      env = { 'rack.input' => 'some input' }
-
-      live_parameters.should_receive(:parameters).once.with({}).and_return Hash.new
-
-      adapter.to_app.call env
-    end
-  end
-
-end

data/spec/lib/adapters/rack/query_spec.rb

@@ -1,39 +0,0 @@
-# encoding: utf-8
-#
-require 'spec_helper'
-
-describe Picky::Adapters::Rack::Search do
-  
-  before(:each) do
-    @query   = stub :query
-    @adapter = described_class.new @query
-  end
-  
-  describe 'to_app' do
-    it 'works' do
-      lambda { @adapter.to_app }.should_not raise_error
-    end
-    it 'returns the right thing' do
-      @adapter.to_app.should respond_to(:call)
-    end
-  end
-  
-  describe 'extracted' do
-    it 'extracts the query' do
-      @adapter.extracted('query' => 'some_query')[0].should == 'some_query'
-    end
-    it 'extracts the default ids amount' do
-      @adapter.extracted('query' => 'some_query')[1].should == 20
-    end
-    it 'extracts the default offset' do
-      @adapter.extracted('query' => 'some_query')[2].should == 0
-    end
-    it 'extracts a given ids amount' do
-      @adapter.extracted('query' => 'some_query', 'ids' => '123')[1].should == 123
-    end
-    it 'extracts a given offset' do
-      @adapter.extracted('query' => 'some_query', 'offset' => '123')[2].should == 123
-    end
-  end
-  
-end

data/spec/lib/application_spec.rb

@@ -1,155 +0,0 @@
-# encoding: utf-8
-#
-require 'spec_helper'
-
-describe Picky::Application do
-
-  describe "integration" do
-    it "should run ok" do
-      lambda {
-        class MinimalTestApplication < described_class
-          books = Picky::Index.new :books do
-                  source Picky::Sources::DB.new(
-                    'SELECT id, title FROM books',
-                    :file => 'app/db.yml'
-                  )
-                  end
-          books.category :title
-
-          rack_adapter.stub! :exclaim # Stopping it from exclaiming.
-
-          route %r{^/books} => Picky::Search.new(books)
-        end
-        Picky::Tokenizer.index_default.tokenize 'some text'
-        Picky::Tokenizer.query_default.tokenize 'some text'
-      }.should_not raise_error
-    end
-    it "should run ok" do
-      lambda {
-        # Here we just test if the API can be called ok.
-        #
-        class TestApplication < described_class
-          indexing  removes_characters:                 /[^a-zA-Z0-9\s\/\-\"\&\.]/,
-                    stopwords:                          /\b(and|the|of|it|in|for)\b/,
-                    splits_text_on:                     /[\s\/\-\"\&\.]/,
-                    removes_characters_after_splitting: /[\.]/,
-                    normalizes_words:                   [[/\$(\w+)/i, '\1 dollars']],
-                    rejects_token_if:                   lambda { |token| token.blank? || token == :amistad }
-
-          searching removes_characters: /[^a-zA-Z0-9äöü\s\/\-\,\&\"\~\*\:]/,
-                    stopwords:          /\b(and|the|of|it|in|for)\b/,
-                    splits_text_on:     /[\s\/\-\,\&]+/,
-                    normalizes_words:   [[/Deoxyribonucleic Acid/i, 'DNA']],
-
-                    substitutes_characters_with: Picky::CharacterSubstituters::WestEuropean.new,
-                    maximum_tokens: 5
-
-          books_index = Picky::Index.new :books do
-            source Picky::Sources::DB.new(
-              'SELECT id, title, author, isbn13 as isbn FROM books',
-              :file => 'app/db.yml'
-            )
-          end
-
-          books_index.category :title,
-                               similarity: Picky::Similarity::DoubleMetaphone.new(3) # Up to three similar title word indexed.
-          books_index.category :author,
-                               similarity: Picky::Similarity::Soundex.new(2)
-          books_index.category :isbn,
-                                      partial: Picky::Partial::None.new # Partially searching on an ISBN makes not much sense.
-
-          geo_index = Picky::Index.new :geo do
-            source          Picky::Sources::CSV.new(:location, :north, :east, file: 'data/ch.csv', col_sep: ',')
-            indexing        removes_characters: /[^a-z]/
-            category        :location,
-                            similarity: Picky::Similarity::Metaphone.new(4)
-            ranged_category :north1, 1, precision: 3, from: :north
-            ranged_category :east1,  1, precision: 3, from: :east
-          end
-
-          rack_adapter.stub! :exclaim # Stopping it from exclaiming.
-
-          route %r{^/books} => Picky::Search.new(books_index)
-
-          buks_search = Picky::Search.new(books_index) do
-            searching removes_characters: /[buks]/
-            ignore    :author
-          end
-          route %r{^/buks} => buks_search
-        end
-      }.should_not raise_error
-    end
-  end
-
-  describe 'finalize' do
-    before(:each) do
-      described_class.stub! :check
-    end
-    it 'checks if all is ok' do
-      described_class.should_receive(:check).once.with
-
-      described_class.finalize
-    end
-    it 'tells the rack adapter to finalize' do
-      described_class.rack_adapter.should_receive(:finalize).once.with
-
-      described_class.finalize
-    end
-  end
-
-  describe 'check' do
-    it 'does something' do
-      described_class.should_receive(:warn).once.with "\nWARNING: No routes defined for application configuration in Class.\n\n"
-
-      described_class.check
-    end
-  end
-
-  describe 'delegation' do
-    it "should delegate route" do
-      described_class.rack_adapter.should_receive(:route).once.with :path => :query
-
-      described_class.route :path => :query
-    end
-  end
-
-  describe 'rack_adapter' do
-    it 'should be there' do
-      lambda { described_class.rack_adapter }.should_not raise_error
-    end
-    it "should return a new FrontendAdapters::Rack instance" do
-      described_class.rack_adapter.should be_kind_of(Picky::FrontendAdapters::Rack)
-    end
-    it "should cache the instance" do
-      described_class.rack_adapter.should == described_class.rack_adapter
-    end
-  end
-
-  describe 'route' do
-    it 'is delegated' do
-      described_class.rack_adapter.should_receive(:route).once.with :some_options
-
-      described_class.route(:some_options)
-    end
-    it 'raises on block' do
-      expect {
-        described_class.route :quack => Hash.new do # Anything with a block.
-          # do something
-        end
-      }.to raise_error("Warning: block passed into #route method, not into Search.new!")
-    end
-  end
-
-  describe 'call' do
-    before(:each) do
-      @routes = stub :routes
-      described_class.stub! :rack_adapter => @routes
-    end
-    it 'should delegate' do
-      @routes.should_receive(:call).once.with :env
-
-      described_class.call :env
-    end
-  end
-
-end

data/spec/lib/frontend_adapters/rack_spec.rb

@@ -1,294 +0,0 @@
-# encoding: utf-8
-#
-require 'spec_helper'
-
-describe Picky::FrontendAdapters::Rack do
-  
-  before(:each) do
-    @rack_adapter = described_class.new
-    @rack_adapter.stub! :exclaim
-  end
-  
-  def rack_defaults_for url
-    url, query_string = url.split ??
-    
-    { "GATEWAY_INTERFACE"=>"CGI/1.1",
-      "PATH_INFO"=>"#{url}",
-      "QUERY_STRING"=>"#{query_string}",
-      "REMOTE_ADDR"=>"127.0.0.1",
-      "REMOTE_HOST"=>"localhost",
-      "REQUEST_METHOD"=>"GET",
-      "REQUEST_URI"=>"http://localhost:3001#{url}",
-      "SCRIPT_NAME"=>"",
-      "SERVER_NAME"=>"localhost",
-      "SERVER_PORT"=>"3001",
-      "SERVER_PROTOCOL"=>"HTTP/1.1",
-      "SERVER_SOFTWARE"=>"WEBrick/1.3.1 (Ruby/1.9.2/2010-07-11)",
-      "HTTP_HOST"=>"localhost:3001",
-      "HTTP_USER_AGENT"=>"Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_8; en-us) AppleWebKit/533.16 (KHTML like Gecko) Version/5.0 Safari/533.16",
-      "HTTP_ACCEPT"=>"application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5",
-      "HTTP_CACHE_CONTROL"=>"max-age=0",
-      "HTTP_ACCEPT_LANGUAGE"=>"en-us",
-      "HTTP_ACCEPT_ENCODING"=>"gzip,
-      deflate",
-      "HTTP_COOKIE"=>"__utma=111872281.1536032598.1255697925.1255697925.1255697925.1; _jsuid=8971917605087477351; locale=de",
-      "HTTP_CONNECTION"=>"keep-alive",
-      "rack.input"=>'' }
-  end
-  
-  context 'empty?' do
-    context 'no routes' do
-      before(:each) do
-        @rack_adapter.reset_routes
-      end
-      it 'returns the right answer' do
-        @rack_adapter.empty?.should == true
-      end
-    end
-    context 'with routes' do
-      before(:each) do
-        @rack_adapter.route %r{something} => Picky::Search.new
-      end
-      it 'returns the right answer' do
-        @rack_adapter.empty?.should == false
-      end
-      describe 'to_s' do
-        it 'outputs correctly' do
-          @rack_adapter.to_s.should == "Note: Anchored (✓) regexps are faster, e.g. /\\A.*\\Z/ or /^.*$/.\n\n   something => Picky::Search(weights: Picky::Query::Weights({}))"
-        end
-      end
-    end
-  end
-  
-  context 'real routes' do
-    before(:each) do
-      @rack_adapter.reset_routes
-      Picky.logger.stub! :info
-    end
-    it 'should route correctly' do
-      env = {}
-      
-      @rack_adapter.routes.freeze
-      @rack_adapter.call(env).should == [404, {"Content-Type" => "text/html", "X-Cascade" => "pass"}, ["Not Found"]]
-    end
-    it 'should route correctly' do
-      env = rack_defaults_for '/'
-      
-      @rack_adapter.root 200
-      
-      @rack_adapter.routes.freeze
-      @rack_adapter.call(env).should == [200, {"Content-Type"=>"text/html", "Content-Length"=>"0"}, ['']]
-    end
-    it 'should route correctly' do
-      env = rack_defaults_for '/blarf'
-      
-      @rack_adapter.default 200
-      
-      @rack_adapter.routes.freeze
-      @rack_adapter.call(env).should == [200, {"Content-Type"=>"text/html", "Content-Length"=>"0"}, ['']]
-    end
-    it 'should route correctly' do
-      env = rack_defaults_for '/gurk'
-      
-      @rack_adapter.answer %r{/gurk}, lambda { |env| [333, {}, ['this is gurk']] }
-      
-      @rack_adapter.routes.freeze
-      @rack_adapter.call(env).should == [333, {}, ['this is gurk']]
-    end
-    it 'should route correctly' do
-      env = rack_defaults_for '/gurk'
-      
-      @rack_adapter.answer '/gurk', lambda { |env| [333, {}, ['this is gurk']] }
-      
-      @rack_adapter.routes.freeze
-      @rack_adapter.call(env).should == [333, {}, ['this is gurk']]
-    end
-    it 'should route correctly' do
-      env = rack_defaults_for '/searches/some_route?query=some_query'
-      
-      search = stub :search
-      search.should_receive(:search).once.with(anything, 20, 0).and_return(Picky::Results.new)
-      Picky::Search.stub! :new => search
-      
-      @rack_adapter.route '/searches/some_route' => Picky::Search.new(:some_index, :some_other_index)
-      
-      @rack_adapter.routes.freeze
-      @rack_adapter.call(env).should == [200, {"Content-Type"=>"application/json", "Content-Length"=>"52"}, ["{\"allocations\":[],\"offset\":0,\"duration\":0,\"total\":0}"]]
-    end
-    it 'should route correctly' do
-      env = rack_defaults_for '/searches/some_route?query=some_query&type=some_type'
-      
-      search = stub :search
-      search.should_receive(:search).once.with(anything, 20, 0).and_return(Picky::Results.new)
-      Picky::Search.stub! :new => search
-      
-      @rack_adapter.route '/searches/some_route' => Picky::Search.new(:some_index, :some_other_index), :query => { :type => :some_type }
-      
-      @rack_adapter.routes.freeze
-      @rack_adapter.call(env).should == [200, {"Content-Type"=>"application/json", "Content-Length"=>"52"}, ["{\"allocations\":[],\"offset\":0,\"duration\":0,\"total\":0}"]]
-    end
-    it 'should route correctly' do
-      env = rack_defaults_for '/searches/some_wrong_route?query=some_query'
-      
-      search = stub :search
-      search.should_receive(:search).never
-      Picky::Search.stub! :new => search
-      
-      @rack_adapter.route '/searches/some_route' => Picky::Search.new(:some_index, :some_other_index)
-      
-      @rack_adapter.routes.freeze
-      @rack_adapter.call(env).should == [404, {"Content-Type"=>"text/html", "X-Cascade"=>"pass"}, ["Not Found"]]
-    end
-  end
-  
-  describe 'to_s' do
-    context 'no routes' do
-      it 'outputs correctly' do
-        @rack_adapter.to_s.should == "Note: Anchored (✓) regexps are faster, e.g. /\\A.*\\Z/ or /^.*$/.\n\n"
-      end
-    end
-  end
-  
-  context 'stubbed routes' do
-    before(:each) do
-      @routes = stub :routes
-      @rack_adapter.stub! :routes => @routes
-    end
-    
-    describe 'generate_query_string' do
-      it 'should not allow an empty query condition' do
-        lambda {
-          @rack_adapter.generate_query_string({}).should == 'this=must_be'
-        }.should raise_error "At least one query string condition is needed."
-      end
-      it 'should handle a single condition' do
-        @rack_adapter.generate_query_string(:this => :must_be).should == 'this=must_be'
-      end
-      it 'should not allow multiple query strings' do
-        lambda {
-          @rack_adapter.generate_query_string(:this => :must_be, :that => :should_be).should == 'this=must_be|that=should_be'
-        }.should raise_error "Too many query param conditions (only 1 allowed): {:this=>:must_be, :that=>:should_be}"
-      end
-      it 'should be sanity checked' do
-        '/searches/some_route?query=some_query&type=some_type'.should match(%r{#{"type=some_type"}})
-      end
-    end
-    
-    describe "route" do
-      it "should delegate correctly" do
-        @rack_adapter.should_receive(:route_one).once.with %r{regexp1}, :query1, {}
-        @rack_adapter.should_receive(:route_one).once.with %r{regexp2}, :query2, {}
-        
-        @rack_adapter.route %r{regexp1} => :query1, %r{regexp2} => :query2
-      end
-      it "should split options correctly" do
-        @rack_adapter.should_receive(:route_one).once.with %r{regexp1}, :query1, :some => :option
-        @rack_adapter.should_receive(:route_one).once.with %r{regexp2}, :query2, :some => :option
-        
-        @rack_adapter.route %r{regexp1} => :query1, %r{regexp2} => :query2, :some => :option
-      end
-      it 'does not accept nil queries' do
-        lambda { @rack_adapter.route %r{some/regexp} => nil }.should raise_error(Picky::FrontendAdapters::Rack::RouteTargetNilError, /Routing for \/some\\\/regexp\/ was defined with a nil target object, i.e. \/some\\\/regexp\/ => nil./)
-      end
-    end
-    
-    describe 'finalize' do
-      before(:each) do
-        @rack_adapter.routes.should_receive(:freeze).once.with
-        
-        @rack_adapter.finalize
-      end
-    end
-    
-    describe 'route_one' do
-      before(:each) do
-        Picky::Adapters::Rack.stub! :app_for => :some_query_app
-      end
-      it 'should add the right route' do
-        @routes.should_receive(:add_route).once.with :some_query_app, { :request_method => "GET", :path_info => /some_url/ }, {}, "some_query"
-        
-        @rack_adapter.route_one %r{some_url}, :some_query, {}
-      end
-      it 'should add the right route' do
-        @routes.should_receive(:add_route).once.with :some_query_app, { :request_method => "GET", :path_info => /some_url/ }, {}, "some_query"
-        
-        @rack_adapter.route_one 'some_url', :some_query, {}
-      end
-      it 'should add the right route' do
-        @routes.should_receive(:add_route).once.with :some_query_app, { :request_method => "GET", :glarf => :blarf, :path_info => /some_url/ }, {}, "some_query"
-        
-        @rack_adapter.route_one 'some_url', :some_query, { :glarf => :blarf }
-      end
-    end
-    
-    describe 'default' do
-      it 'should call answer' do
-        @rack_adapter.should_receive(:answer).once.with nil, Picky::FrontendAdapters::Rack::STATUSES[200]
-        
-        @rack_adapter.default 200
-      end
-    end
-    
-    describe 'STATUSES' do
-      it 'is a lambda' do
-        Picky::FrontendAdapters::Rack::STATUSES[200].respond_to?(:call).should == true
-      end
-      it 'is a lambda' do
-        Picky::FrontendAdapters::Rack::STATUSES[404].respond_to?(:call).should == true
-      end
-    end
-    
-    describe 'root' do
-      it 'should call answer' do
-        @rack_adapter.should_receive(:answer).once.with %r{^/$}, Picky::FrontendAdapters::Rack::STATUSES[200]
-        
-        @rack_adapter.root 200
-      end
-      it 'should call answer' do
-        @rack_adapter.should_receive(:answer).once.with %r{^/$}, Picky::FrontendAdapters::Rack::STATUSES[404]
-        
-        @rack_adapter.root 404
-      end
-    end
-    
-    describe 'answer' do
-      context 'with app' do
-        before(:each) do
-          @app = stub :app
-        end
-        context 'with url' do
-          it 'should use the app with default_options from the url' do
-            @routes.should_receive(:add_route).once.with @app, { :request_method => "GET", :path_info => /some_url/ }
-            
-            @rack_adapter.answer 'some_url', @app
-          end
-        end
-        context 'without url' do
-          it 'should use the app with default_options' do
-            @routes.should_receive(:add_route).once.with @app, { :request_method => "GET" }
-            
-            @rack_adapter.answer nil, @app
-          end
-        end
-      end
-      context 'without app' do
-        context 'with url' do
-          it 'should use the 200 with default_options from the url' do
-            @routes.should_receive(:add_route).once.with Picky::FrontendAdapters::Rack::STATUSES[200], { :request_method => "GET", :path_info => /some_url/ }
-            
-            @rack_adapter.answer 'some_url'
-          end
-        end
-        context 'without url' do
-          it 'should use the 200 with default_options' do
-            @routes.should_receive(:add_route).once.with Picky::FrontendAdapters::Rack::STATUSES[200], { :request_method => "GET" }
-            
-            @rack_adapter.answer
-          end
-        end
-      end
-    end
-    
-  end
-  
-end