ShyCouch 0.6.0 → 0.7.0

data/Gemfile

@@ -3,7 +3,9 @@ source "http://rubygems.org"
 # Example:
 #   gem "activesupport", ">= 2.3.5"
 
-gem "ShyRubyJS"
+gem "rest-client", ">= 0"
+gem "sourcify", "~> 0.5.0"
+gem "ShyRubyJS", ">= 0.2.0"
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
@@ -11,6 +13,5 @@ group :development do
   gem "bundler", "~> 1.0.0"
   gem "jeweler", "~> 1.6.4"
   gem "rcov", ">= 0"
-  gem "sourcify", "~> 0.5.0"
-  gem "ShyRubyJS"
+
 end

data/Rakefile

@@ -21,9 +21,10 @@ Jeweler::Tasks.new do |gem|
   gem.description = %Q{Ruby API for CouchDB, designed to work with the Camping micro-framework.}
   gem.email = "danbryan@gmail.com"
   gem.authors = ["Shy Inc.", "Daniel Bryan", "Cerales"]
-  gem.add_dependency "ShyRubyJS"
+  gem.add_dependency "ShyRubyJS", ">= 0.2.0"
   gem.add_dependency "rest-client", ">=1.6.7"
   gem.add_dependency "sourcify", ">=0"
+  gem.add_dependency "mime-types", ">=0"
   # dependencies defined in Gemfile
 end
 Jeweler::RubygemsDotOrgTasks.new

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.7.0

data/lib/ShyCouch.rb

@@ -17,27 +17,29 @@ require 'ShyRubyJS'
 require 'ShyCouch/data'
 require 'ShyCouch/fields'
 
-
 module ShyCouch
   class << self
-    def getDB(settings)
-      # this is a wrapper for creating CouchDatabase object and testing that it can connect
-      database = CouchDatabase.new(settings)
-      puts database.connect unless database.connect["ok"] #TODO - hm
-      database.create! unless database.exists?
-      return database
-    end
+		def getDB(settings)
+		  # this is a wrapper for creating CouchDatabase object and testing that it can connect
+		  database = CouchDatabase.new(settings)
+		  puts database.connect unless database.connect["ok"] #TODO - hm
+		  database.create! unless database.exists?
+		  return database
+		end
   end
   attr_accessor :database
 
-  class ShyCouchError < StandardError; end
-  
+  class ShyCouchError < StandardError; end  
   class ShyCouchDesignMissing < ShyCouchError; end
+  class ShyCouch::DatabaseError < ShyCouchError; end
+  class ShyCouch::ViewError < ShyCouchError; end
+  class ShyCouch::DesignConflict < ShyCouchError; end
+	class ShyCouch::ResourceNotFound < ShyCouchError; end
+  class ShyCouch::DocumentValidationError < ShyCouchError; end
 
   class CouchDatabase
   	def initialize(settings)
-      raise StandardError, "invalid settings" if settings == nil
-	    init(settings)
+			init(settings)
   	end
 
   	attr_accessor :server, :name, :host, :port, :design_documents, :designs
@@ -55,216 +57,290 @@ module ShyCouch
 	  end
   	def server_responds?; return @server.responds?; end
 
-    def design(design)
-      if design.kind_of?(ShyCouch::Data::Design)
-        return design_by_name(design.name)
-      else
-        return design_by_name(design)
-      end
-    end
-    
-    def design_by_name(name)
-      @designs.each { |design| return design if design.name == name.to_s }
-      return nil
+    def init!
+      create! unless exists?
     end
+		def design(design)
+		  if design.kind_of?(ShyCouch::Data::Design)
+				return design_by_name(design.name)
+		  else
+				return design_by_name(design)
+		  end
+		end
+		
+		def design_by_name(name)
+		  @designs.each { |design| return design if design.name == name.to_s }
+		  return nil
+		end
 
-    def exists?
-      @server.has_database?(@name)
-    end
+		def exists?
+		  @server.has_database?(@name)
+		end
   	def create!
   		@server.create_db(@name)
   	end
-    def get_document_by_id(id)
-      @server.get_document_by_id(@name, id)
-    end
+		def get_document_by_id(id)
+		  @server.get_document_by_id(@name, id)
+		end
 
-    def pull_design(designName)
-      doc = @server.get_document_by_id(@name, designName)
-      return ShyCouch::Data::Design.new(designName).merge! doc
-    end
-    def all_docs
-      get_document_by_id('_all_docs').rows.map { |doc|
-        get_document_by_id(doc["id"])
-      }
-    end
-    def uri
-      return "http://#{host}/#{port}/#{name}"
-    end
+		def pull_design(designName)
+		  doc = @server.get_document_by_id(@name, designName)
+		  return ShyCouch::Data::Design.new(designName).merge! doc
+		end
+		def all_docs
+		  get_document_by_id('_all_docs').rows.map { |doc|
+				get_document_by_id(doc["id"])
+		  }
+		end
+		def uri
+		  return "http://#{host}/#{port}/#{name}"
+		end
 
-    def pull_document(document)
-      @server.pull_document(self.name, document)
-    end
+		def pull_document(document)
+		  @server.pull_document(self.name, document)
+		rescue RestClient::ResourceNotFound
+			raise ShyCouch::ResourceNotFound
+		end
 
-    def push_document!(document)
-      @server.push_document(self.name, document)
-    end
-    
-    def query_view(design_name, view_name)
-      queryString = "/_design/#{design_name}/_view/#{view_name}"
-      ShyCouch::Data::ViewResult.new(get_document_by_id(queryString))
-    end
-    
-    def add_design(design)
-      throw TypeError unless design.kind_of?(ShyCouch::Data::Design)
-      # if the db has already stored the design, update it
-      if design_by_name(design.name) != nil
-        design_by_name(design.name) == design
-      end
-      # otherwise, add it
-      @designs << design
-    end
-    
-    def add_designs_and_push!(*docs)
-      docs.each do |doc|
-        add_design(doc)
-      end
-      push_designs!
-    end
-    
-    def add_design_and_push!(doc)
-      add_design(doc)
-      push_designs!
-    end
-    
-    def push_designs!
-      @designs.each do |design|
-        # push the document and update it with the rev sent by the response
-        design["_rev"] = push_document!(design)["rev"]
+		def push_document!(doc, opts = {})
+		  raise(ShyCouch::DocumentValidationError, "Document missing required fields: #{doc.missing_needs}") unless doc.satisfies_needs?
+		  raise ShyCouch::DocumentValidationError, "Document missing suggested fields, not overriden: #{doc.missing_suggestions}" unless doc.satisfies_suggestions?(opts)
+		  @server.push_document(self.name, doc)
+		end
+
+		def delete_document!(doc, opts = {})
+			if !doc._id
+				if !doc._rev
+					raise ShyCouch::DocumentValidationError, "Cannot delete document without id and rev" unless doc._id
+				else
+					raise ShyCouch::DocumentValidationError, "Cannot delete document without id" unless doc._id
+				end
+			elsif !doc._rev
+				raise ShyCouch::DocumentValidationError, "Cannot delete document without id" unless doc._id
+			end
+			@server.delete_document(self.name, doc)
+		end
+		
+		def query_view(design_name, view_name, opts = {})
+			# build query string from the options
+			uri = "_design/#{design_name}/_view/#{view_name}"
+			uri += "?#{query_string opts}" if opts.length > 0
+		  result = ShyCouch::Data::ViewResultHandler.init(get_document_by_id(uri))
+      if opts.has_key? :key and result.length == 1
+        # Return it as a document if it was a key query
+        return result[0]
+      else
+			  return result
       end
-    end
-    
-    def view(design, view_obj)
-      url = "#{design._id}/_view/#{view_obj.name}"
-      get_document_by_id(url)
-    end
-    
-    private 
-    
-    def init(settings, design_documents = [])
+		end
+
+		def query_string(opts = {})
+			# builds a http query string from options
+      # need to stringify key queries
+			exceptions = [:from] # stuff that might get passed in that's not for a query option
+
+      return opts.map{ |k,v|
+        raise ShyCouch::ViewError, "Illegal view option: #{k}" unless @legal_view_options.has_key? k
+        if @legal_view_options[k][:stringify] == true
+          "#{k.to_s}=#{URI.escape(v.to_s.to_json)}" if !exceptions.include? k
+        else
+          "#{k.to_s}=#{v.to_s}" if !exceptions.include? k
+        end
+      }.join("&")
+		end
+		
+		def add_design(design)
+		  throw TypeError unless design.kind_of?(ShyCouch::Data::Design)
+		  # if the db has already stored the design, update it
+		  if design_by_name(design.name) != nil
+				design_by_name(design.name) == design
+		  end
+		  # otherwise, add it
+		  @designs << design
+		end
+		
+		def add_designs_and_push!(*docs)
+		  docs.each do |doc|
+				add_design(doc)
+		  end
+		  push_designs!
+		end
+		
+		def add_design_and_push!(doc)
+		  add_design(doc)
+		  push_designs!
+		end
+		
+		def push_designs!
+		  @designs.each do |design|
+				# push the document and update it with the rev sent by the response
+				begin
+				  design._rev = push_document!(design)["rev"]
+				rescue ShyCouch::DesignConflict => e
+				  # Get the rev of the existing one, then try again!
+				  # If that fails, it should still throw an error
+				  existing_design = get_document_by_id design._id
+				  design._rev = existing_design._rev
+				  design._rev = push_document!(design)["rev"]
+				end
+		  end
+		end
+		
+		def view(design, view_obj)
+		  url = "#{design._id}/_view/#{view_obj.name}"
+		  get_document_by_id(url)
+		end
+		
+		private 
+		
+		def init(settings, design_documents = [])
+			validate_settings settings
 		  db_settings = settings["db"]
   		@host, @port, @name, @user, @password = db_settings["host"],db_settings["port"], db_settings["name"],db_settings["user"], db_settings["password"]
   		@designs = ShyCouch::Data::CouchDocumentCollection.new
   		@server = CouchServerConnection.allocate
-    end
-    
-    class CouchServerConnection
-    	def initialize(args, options=nil)#host, port, user, password, options = nil)
-    		@host = args["host"]
-    		@port = args["port"]
-    		@user = args["user"]
-    		@password = args["password"]
-    		@db_name = args["database"]
-    		@options = options
-    	end
+      @legal_view_options = {
+        :key => { :stringify => true },
+        :startkey => { :stringify => true },
+        :startkey_docid => { :stringify => false },
+        :endkey => { :stringify => true },
+        :endkey_docid => { :stringify => false },
+        :limit => { :stringify => false },
+        :stale => { :stringify => false },
+        :descending => { :stringify => false },
+        :skip => { :stringify => false },
+        :group => { :stringify => false },
+        :group_level => { :stringify => false },
+        :reduce => { :stringify => false },
+        :include_docs => { :stringify => false },
+        :inclusive_end => { :stringify => false },
+        :update_seq => { :stringify => false }
+      }
+		end
 
-    	def responds?
-    		if req(:get, "/")['couchdb'] == "Welcome"
-    			true
-    		else
-    			false
-    		end
-    	rescue Errno::ECONNREFUSED
-    		false
-    	end
+		def validate_settings settings
+			# Should check that host and port exist
+			# and that database name is specified
+			# and that there is a password if there is a username
+			raise ShyCouch::DatabaseError unless settings["db"]
+			raise ShyCouch::DatabaseError unless settings["db"]["host"]
+			raise ShyCouch::DatabaseError unless settings["db"]["port"]
+			raise ShyCouch::DatabaseError unless settings["db"]["name"]
+			if settings["db"]["user"]
+				raise ShyCouch::DatabaseError unless settings["db"]["password"]
+			end
+		end
+		
+		class CouchServerConnection
+			def initialize(args, options=nil)#host, port, user, password, options = nil)
+				@host = args["host"]
+				@port = args["port"]
+				@user = args["user"]
+				@password = args["password"]
+				@db_name = args["database"]
+				@options = options
+			end
 
-    	def has_database?(db_name)
-    	  req(:get, "/#{db_name}/")
-    		true
-    	rescue RestClient::ResourceNotFound
-    		false
-    	end
-      
-      def req(kind, uri, data = nil)
-        raise TypeError unless [:get,:delete,:put,:post].include?(kind) # only support these 4 request methods currently
-        res = (@user and @password ? couch_req_with_auth(kind, uri, data) : couch_req_without_auth(kind, uri, data))
-        return JSON.parse(res)
-      end
-      def req_host
-        "http://#{(@user + ':' + @password + '@') if @user and @password}#{@host}:#{@port}"
-      end
-      def couch_req_with_auth(kind, uri = nil, data = nil)
-        uri ? uri = req_host + uri : uri = req_host
-        if kind == :get or kind == :delete
-          RestClient.method(kind).call(uri, :content_type => :json, :user => @user, :password => @password)  
-        else
-          RestClient.method(kind).call(uri, data, :content_type => :json)#, :user => @user, :password => @password)  
-        end
-      end
-      def couch_req_without_auth(kind, uri, data = nil)
-        uri ? uri = req_host + uri : uri = req_host
-        if kind == :get or kind == :delete
-          RestClient.method(kind).call(uri, :content_type => :json, :user => @user, :password => @password)  
-        else
-          RestClient.method(kind).call(uri, data,:content_type => :json, :user => @user, :password => @password)  
-        end
-        
-      end
-      #TODO - this is screwed
-    	def pull_all_doc_ids(db_name)
-        req(:get,"/#{db_name}/_all_docs")["rows"].map { |doc| doc["id"] }
-    	end
+			def responds?
+				if req(:get, "/")['couchdb'] == "Welcome"
+					true
+				else
+					false
+				end
+			rescue Errno::ECONNREFUSED
+				false
+			end
 
-    	def all_docs_from_database(db_name)
-    	  pull_all_doc_ids(db_name).map { |id| Data::CouchDocument.new(req(:get,"/#{db_name}/#{id}")) }
-    	end
+			def has_database?(db_name)
+			  req(:get, "/#{db_name}/")
+				true
+			rescue RestClient::ResourceNotFound
+				false
+			end
+		  
+		  def req(kind, uri, data = nil)
+				raise TypeError unless [:get,:delete,:put,:post].include?(kind) # only support these 4 request methods currently
+				if @user and @password
+					res = couch_req_with_auth kind, uri, data
+				else
+					res = couch_req_without_auth kind, uri, data
+				end
+				return JSON.parse(res)
+		  rescue RestClient::Conflict => e
+				# attempting to update without rev will throw this error
+				
+				# sometimes it's because a server booted and tried to push design documents that existed:
+				if JSON.parse(data)["_id"].include? "_design"
+				  # throw a different error
+				  raise ShyCouch::DesignConflict, "Design document update refused, or other resource conflict."
+				else
+				  raise e
+				end
+				
+		  end
+		  def req_host
+				"http://#{(@user + ':' + @password + '@') if @user and @password}#{@host}:#{@port}"
+		  end
+		  def couch_req_with_auth(kind, uri = nil, data = nil)
+				uri ? uri = req_host + uri : uri = req_host
+				if kind == :get or kind == :delete
+				  RestClient.method(kind).call(uri, :content_type => :json, :user => @user, :password => @password)  
+				else
+				  RestClient.method(kind).call(uri, data, :content_type => :json, :user => @user, :password => @password)  
+				end
+		  end
+		  def couch_req_without_auth(kind, uri, data = nil)
+				uri ? uri = req_host + uri : uri = req_host
+				if kind == :get or kind == :delete
+				  RestClient.method(kind).call(uri, :content_type => :json)  
+				else
+				  RestClient.method(kind).call(uri, data,:content_type => :json)  
+				end
+				
+		  end
+		  #TODO - this is screwed
+			def pull_all_doc_ids(db_name)
+				req(:get,"/#{db_name}/_all_docs")["rows"].map { |doc| doc["id"] }
+			end
 
-    	def get_document_by_id(db_name, id)
-    		document = Data::CouchDocument.new(:data => req(:get,"/#{db_name}/#{id}"))
-    	end
-    	def pull_document(db_name, document)
-    		document = Data::CouchDocument.new(:data => req(:get,"/#{db_name}/#{document._id}"))  	    
-	    end
+			def all_docs_from_database(db_name)
+			  pull_all_doc_ids(db_name).map { |id| Data::CouchDocument.new(req(:get,"/#{db_name}/#{id}")) }
+			end
 
-    	def delete_document(db_name, id)
-    		delete("/#{db_name}/#{id}")
-    		RestClient.delete ""
-    	end
+			def get_document_by_id(db_name, id)
+				document = Data::CouchDocument.new(:data => req(:get,"/#{db_name}/#{id}"))
+			end
+			def pull_document(db_name, document)
+				document = Data::CouchDocument.new(:data => req(:get,"/#{db_name}/#{document._id}"))  			
+			end
 
-      # Haven't decided whether PUT/POST should take a CouchDocument or a JSON string.
+		  # Haven't decided whether PUT/POST should take a CouchDocument or a JSON string.
 
-    	def push_document(db_name, document)
-    	  raise TypeError unless document.kind_of?(ShyCouch::Data::CouchDocument)
-    	  raise JSON::GeneratorError unless document.valid?
-    	  if document["_rev"]
-          # puts "/#{db_name}/#{document._id}?rev=#{document._rev}/" #TODO - remove
-    	    return req(:put, "/#{db_name}/#{document._id}?rev=#{document._rev}/", document.to_json)
-  	    elsif document["_id"]
-  	      return req(:put, "/#{db_name}/#{document._id}", document.to_json)
-	      else
-  	      return req(:post, "/#{db_name}/", document.to_json)
-  	    end
+			def push_document(db_name, document)
+			  raise TypeError unless document.kind_of?(ShyCouch::Data::CouchDocument)
+			  raise JSON::GeneratorError unless document.valid?
+			  if document["_rev"]
+					return req(:put, "/#{db_name}/#{document._id}?rev=#{document._rev}/", document.to_json)
+  			elsif document["_id"]
+  			  return req(:put, "/#{db_name}/#{document._id}", document.to_json)
+			  else
+  			  return req(:post, "/#{db_name}/", document.to_json)
+  			end
   	  end
 
-    	def create_db(db_name)
-    		req(:put, "/#{db_name}/")
-    	end
-    	def delete_db(db_name)
-    		req(:delete,"/#{db_name}/")
-    	end
+			def delete_document(db_name, document)
+				raise TypeError unless document.kind_of?(ShyCouch::Data::CouchDocument)
+				return req(:delete, "/#{db_name}/#{document._id}?rev=#{document._rev}")
+			end
 
-    	private
+			def create_db(db_name)
+				req(:put, "/#{db_name}/")
+			end
+			def delete_db(db_name)
+				req(:delete,"/#{db_name}/")
+			end
 
-      # def handle_failure(req, res)
-      #   raise RuntimeError.new("#{res.code}:#{res.message}\nMETHOD:#{req.method}\nURI:#{req.path}\n#{res.body}")
-      # end
-      # 
-      # def handle_error(e)
-      #   raise RuntimeError.new("#{e.inspect}\n Maybe be due to illegal rev or id change")
-      #       end
-
-      #       def request(req)
-      #         res = Net::HTTP.start(@host, @port) { |http|
-      #           req.basic_auth(@user, @password) if @user and @password
-      #           http.request(req)
-      #           }
-      #         unless res.kind_of?(Net::HTTPSuccess)
-      #           handle_failure(req, res)
-      #         end
-      #         res
-      # rescue Errno::ECONNRESET => e
-      #   handle_error(e)
-      #       end
-    end
+		end
 
   end
 end