sporkd-couchrest 0.30

data/lib/couchrest.rb

@@ -0,0 +1,200 @@
+# Copyright 2008 J. Chris Anderson
+# 
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+# 
+#        http://www.apache.org/licenses/LICENSE-2.0
+# 
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+require 'rubygems'
+begin
+  require 'json'
+rescue LoadError
+  raise "You need install and require your own json compatible library since couchrest rest couldn't load the json/json_pure gem" unless Kernel.const_defined?("JSON")
+end
+require 'rest_client'
+
+$:.unshift File.dirname(__FILE__) unless
+  $:.include?(File.dirname(__FILE__)) ||
+  $:.include?(File.expand_path(File.dirname(__FILE__)))
+    
+require 'couchrest/monkeypatches'
+
+# = CouchDB, close to the metal
+module CouchRest
+  VERSION    = '0.30' unless self.const_defined?("VERSION")
+  
+  autoload :Server,       'couchrest/core/server'
+  autoload :Database,     'couchrest/core/database'
+  autoload :Response,     'couchrest/core/response'
+  autoload :Document,     'couchrest/core/document'
+  autoload :Design,       'couchrest/core/design'
+  autoload :View,         'couchrest/core/view'
+  autoload :Model,        'couchrest/core/model'
+  autoload :Pager,        'couchrest/helper/pager'
+  autoload :FileManager,  'couchrest/helper/file_manager'
+  autoload :Streamer,     'couchrest/helper/streamer'
+  autoload :Upgrade,      'couchrest/helper/upgrade'
+  
+  autoload :ExtendedDocument,     'couchrest/more/extended_document'
+  autoload :CastedModel,          'couchrest/more/casted_model'
+  
+  require File.join(File.dirname(__FILE__), 'couchrest', 'core', 'http_abstraction')
+  require File.join(File.dirname(__FILE__), 'couchrest', 'mixins')
+  require File.join(File.dirname(__FILE__), 'couchrest', 'support', 'rails') if defined?(Rails)
+  
+  # The CouchRest module methods handle the basic JSON serialization 
+  # and deserialization, as well as query parameters. The module also includes
+  # some helpers for tasks like instantiating a new Database or Server instance.
+  class << self
+
+    # extracted from Extlib
+    #
+    # Constantize tries to find a declared constant with the name specified
+    # in the string. It raises a NameError when the name is not in CamelCase
+    # or is not initialized.
+    #
+    # @example
+    # "Module".constantize #=> Module
+    # "Class".constantize #=> Class
+    def constantize(camel_cased_word)
+      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+        raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+      end
+
+      Object.module_eval("::#{$1}", __FILE__, __LINE__)
+    end
+    
+    # extracted from Extlib
+    #    
+    # Capitalizes the first word and turns underscores into spaces and strips _id.
+    # Like titleize, this is meant for creating pretty output.
+    #
+    # @example
+    #   "employee_salary" #=> "Employee salary"
+    #   "author_id" #=> "Author"
+    def humanize(lower_case_and_underscored_word)
+      lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+    end
+    
+    # todo, make this parse the url and instantiate a Server or Database instance
+    # depending on the specificity.
+    def new(*opts)
+      Server.new(*opts)
+    end
+    
+    def parse url
+      case url
+      when /^http:\/\/(.*)\/(.*)\/(.*)/
+        host = $1
+        db = $2
+        docid = $3
+      when /^http:\/\/(.*)\/(.*)/
+        host = $1
+        db = $2
+      when /^http:\/\/(.*)/
+        host = $1
+      when /(.*)\/(.*)\/(.*)/
+        host = $1
+        db = $2
+        docid = $3
+      when /(.*)\/(.*)/
+        host = $1
+        db = $2
+      else
+        db = url
+      end
+
+      db = nil if db && db.empty?
+
+      {
+        :host => host || "127.0.0.1:5984",
+        :database => db,
+        :doc => docid
+      }
+    end
+
+    # set proxy to use
+    def proxy url
+      HttpAbstraction.proxy = url
+    end
+
+    # ensure that a database exists
+    # creates it if it isn't already there
+    # returns it after it's been created
+    def database! url
+      parsed = parse url
+      cr = CouchRest.new(parsed[:host])
+      cr.database!(parsed[:database])
+    end
+  
+    def database url
+      parsed = parse url
+      cr = CouchRest.new(parsed[:host])
+      cr.database(parsed[:database])
+    end
+    
+    def put(uri, doc = nil)
+      payload = doc.to_json if doc
+      begin
+        JSON.parse(HttpAbstraction.put(uri, payload))
+      rescue Exception => e
+        if $DEBUG
+          raise "Error while sending a PUT request #{uri}\npayload: #{payload.inspect}\n#{e}"
+        else
+          raise e
+        end
+      end
+    end
+
+    def get(uri)
+      begin
+        JSON.parse(HttpAbstraction.get(uri), :max_nesting => false)
+      rescue => e
+        if $DEBUG
+          raise "Error while sending a GET request #{uri}\n: #{e}"
+        else
+          raise e
+        end
+      end
+    end
+  
+    def post uri, doc = nil
+      payload = doc.to_json if doc
+      begin
+        JSON.parse(HttpAbstraction.post(uri, payload))
+      rescue Exception => e
+        if $DEBUG
+          raise "Error while sending a POST request #{uri}\npayload: #{payload.inspect}\n#{e}"
+        else
+          raise e
+        end
+      end
+    end
+  
+    def delete uri
+      JSON.parse(HttpAbstraction.delete(uri))
+    end
+    
+    def copy uri, destination
+      JSON.parse(HttpAbstraction.copy(uri, {'Destination' => destination}))
+    end
+  
+    def paramify_url url, params = {}
+      if params && !params.empty?
+        query = params.collect do |k,v|
+          v = v.to_json if %w{key startkey endkey}.include?(k.to_s)
+          "#{k}=#{CGI.escape(v.to_s)}"
+        end.join("&")
+        url = "#{url}?#{query}"
+      end
+      url
+    end
+  end # class << self
+end

data/spec/couchrest/core/couchrest_spec.rb

@@ -0,0 +1,201 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe CouchRest do
+
+  before(:each) do
+    @cr = CouchRest.new(COUCHHOST)
+    begin
+      @db = @cr.database(TESTDB)
+      @db.delete! rescue nil      
+    end
+  end
+
+  after(:each) do
+    begin
+      @db.delete! rescue nil
+    end
+  end
+
+  describe "getting info" do
+    it "should list databases" do
+      @cr.databases.should be_an_instance_of(Array)
+    end
+    it "should get info" do
+      @cr.info["couchdb"].should == "Welcome"
+      @cr.info.class.should == Hash   
+    end
+  end
+  
+  it "should restart" do
+    @cr.restart!
+  end
+
+  it "should provide one-time access to uuids" do
+    @cr.next_uuid.should_not be_nil
+  end
+
+  describe "initializing a database" do
+    it "should return a db" do
+      db = @cr.database(TESTDB)
+      db.should be_an_instance_of(CouchRest::Database)
+      db.host.should == @cr.uri
+    end
+  end
+
+  describe "parsing urls" do
+    it "should parse just a dbname" do
+      db = CouchRest.parse "my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5984"
+    end
+    it "should parse a host and db" do
+      db = CouchRest.parse "127.0.0.1/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1"
+    end
+    it "should parse a host and db with http" do
+      db = CouchRest.parse "http://127.0.0.1/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1"
+    end
+    it "should parse a host with a port and db" do
+      db = CouchRest.parse "127.0.0.1:5555/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+    end
+    it "should parse a host with a port and db with http" do
+      db = CouchRest.parse "http://127.0.0.1:5555/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+    end
+    it "should parse just a host" do
+      db = CouchRest.parse "http://127.0.0.1:5555/"
+      db[:database].should be_nil
+      db[:host].should == "127.0.0.1:5555"
+    end
+    it "should parse just a host no slash" do
+      db = CouchRest.parse "http://127.0.0.1:5555"
+      db[:host].should == "127.0.0.1:5555"
+      db[:database].should be_nil
+    end
+    it "should get docid" do
+      db = CouchRest.parse "127.0.0.1:5555/my-db/my-doc"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+      db[:doc].should == "my-doc"
+    end
+    it "should get docid with http" do
+      db = CouchRest.parse "http://127.0.0.1:5555/my-db/my-doc"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+      db[:doc].should == "my-doc"
+    end
+
+    it "should parse a host and db" do
+      db = CouchRest.parse "127.0.0.1/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1"
+    end
+    it "should parse a host and db with http" do
+      db = CouchRest.parse "http://127.0.0.1/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1"
+    end
+    it "should parse a host with a port and db" do
+      db = CouchRest.parse "127.0.0.1:5555/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+    end
+    it "should parse a host with a port and db with http" do
+      db = CouchRest.parse "http://127.0.0.1:5555/my-db"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+    end
+    it "should parse just a host" do
+      db = CouchRest.parse "http://127.0.0.1:5555/"
+      db[:database].should be_nil
+      db[:host].should == "127.0.0.1:5555"
+    end
+    it "should parse just a host no slash" do
+      db = CouchRest.parse "http://127.0.0.1:5555"
+      db[:host].should == "127.0.0.1:5555"
+      db[:database].should be_nil
+    end
+    it "should get docid" do
+      db = CouchRest.parse "127.0.0.1:5555/my-db/my-doc"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+      db[:doc].should == "my-doc"
+    end
+    it "should get docid with http" do
+      db = CouchRest.parse "http://127.0.0.1:5555/my-db/my-doc"
+      db[:database].should == "my-db"
+      db[:host].should == "127.0.0.1:5555"
+      db[:doc].should == "my-doc"
+    end
+  end
+
+  describe "easy initializing a database adapter" do
+    it "should be possible without an explicit CouchRest instantiation" do
+      db = CouchRest.database "http://127.0.0.1:5984/couchrest-test"
+      db.should be_an_instance_of(CouchRest::Database)
+      db.host.should == "127.0.0.1:5984"
+    end
+    # TODO add https support (need test environment...)
+    # it "should work with https" # do
+    #      db = CouchRest.database "https://127.0.0.1:5984/couchrest-test"
+    #      db.host.should == "https://127.0.0.1:5984"
+    #    end
+    it "should not create the database automatically" do
+      db = CouchRest.database "http://127.0.0.1:5984/couchrest-test"
+      lambda{db.info}.should raise_error(RestClient::ResourceNotFound)      
+    end
+  end
+
+  describe "ensuring the db exists" do
+    it "should be super easy" do
+      db = CouchRest.database! "http://127.0.0.1:5984/couchrest-test-2"
+      db.name.should == 'couchrest-test-2'
+      db.info["db_name"].should == 'couchrest-test-2'
+    end
+  end
+
+  describe "successfully creating a database" do
+    it "should start without a database" do
+      @cr.databases.should_not include(TESTDB)
+    end
+    it "should return the created database" do
+      db = @cr.create_db(TESTDB)
+      db.should be_an_instance_of(CouchRest::Database)
+    end
+    it "should create the database" do
+      db = @cr.create_db(TESTDB)
+      @cr.databases.should include(TESTDB)
+    end
+  end
+
+  describe "failing to create a database because the name is taken" do
+    before(:each) do
+      db = @cr.create_db(TESTDB)
+    end
+    it "should start with the test database" do
+      @cr.databases.should include(TESTDB)
+    end
+    it "should PUT the database and raise an error" do
+      lambda{
+        @cr.create_db(TESTDB)
+      }.should raise_error(RestClient::Request::RequestFailed)
+    end
+  end
+
+  describe "using a proxy for RestClient connections" do
+    it "should set proxy url for RestClient" do
+      CouchRest.proxy 'http://localhost:8888/'
+      proxy_uri = URI.parse(HttpAbstraction.proxy)
+      proxy_uri.host.should eql( 'localhost' )
+      proxy_uri.port.should eql( 8888 )
+      CouchRest.proxy nil
+    end
+  end
+
+end