couchobject 0.5.0 → 0.6.0

data/lib/couch_object/persistable/overloaded_methods.rb

@@ -0,0 +1,209 @@
+module CouchObject
+  module Persistable
+    #####
+    #
+    # Overloaded methods
+    #
+    #####
+
+    #
+    # When saved, clones and dupes are stored as separate documents from 
+    # the object it originated from
+    #   
+    # Returns:
+    # * A new instance of itself where the ID and revision number 
+    #   is set to nil
+    # * the new instance shares the same storage location as the object
+    #   it originates from.
+    # 
+    alias couch_object_origianl_clone clone
+    def clone
+      new_clone = self.couch_object_origianl_clone
+      new_clone.instance_variable_set("@id", nil)
+      new_clone.instance_variable_set("@revision", nil)
+
+      # return the new clone
+      new_clone
+    end
+    def dup
+      clone
+    end
+
+    #
+    # Equality is checked for using the following rules:
+    # * if the object types do not match the result is false
+    # * if the object_id of the class sent as an argument is the same
+    #   as the object_id of self, equal returns true.
+    # * if the two objects have a different class type it fails
+    #   as a result of the object_id test above which can't be true
+    # * fails if the object_id or revision numbers are different
+    # * it fails if one or both of the objects are new and they don't share
+    #   the object_id, because in that case they will be stored as
+    #   separate documents in the database
+    # * is true if all instance_variables are the same
+    # 
+    # Takes:
+    # * +other_object+ which is any object one wishes to compare self to
+    # 
+    # Returns:
+    # * true or false
+    # 
+    def ==(other_object)
+      return false unless self.class == other_object.class
+      return true if self.object_id == other_object.object_id
+      return false if self.id != other_object.id || \
+                      self.revision != other_object.revision
+      return false if self.new? || other_object.new?
+      
+      # All relations should be loaded so that the comparison can be realistic
+      has.each do |what_is_has|
+        self.send(what_is_has)
+        other_object.send(what_is_has) if other_object.
+          respond_to?(what_is_has)
+      end
+      belongs_to.each do |what_it_belongs_to|
+        self.send(what_it_belongs_to)
+        other_object.send(what_it_belongs_to) if other_object.
+          respond_to?(what_it_belongs_to)
+      end
+      
+      self.instance_variables.each do |var|
+        return false if eval(var).to_s != \
+          other_object.instance_variable_get(var).to_s
+      end
+      
+      # has to be true because else it would already have failed :)
+      true      
+    end
+
+    #
+    # Goal:
+    # The goal is to return true for the object which has the newest
+    # representation in the database.
+    #
+    # Requires:
+    # * that both objects have timestamps
+    # 
+    # Returns:
+    # * false if they are equal objects.
+    # * true if self has been saved while the other_object has not.
+    # * false if self hasn't been saved but the other_object has
+    # * true if both have been saved and self has been saved more recently.
+    # * false if both have been saved but the other object more recently.
+    # 
+    # Takes:
+    # * +other_object+ to compare size with
+    # 
+    # Raises:
+    # * CantCompareSize when trying to compare two object that have not
+    #   been saved or saved but do not have timestamps
+    #   
+    # Returns:
+    # * true or false
+    # 
+    def >(other_object)
+      return false if self == other_object
+      unless self.new? && other_object.new?
+        if self.class.couch_object_timestamp_on_update? and \
+            other_object.class.couch_object_timestamp_on_update?
+          return ((self.updated_at || 0).to_i \
+                  > (other_object.updated_at || 0).to_i) \
+                  ? true : false
+        elsif self.class.couch_object_timestamp_on_create? and \
+            other_object.class.couch_object_timestamp_on_create?
+          return ((self.created_at || 0).to_i \
+                  > (other_object.created_at || 0).to_i) \
+                  ? true : false
+        else
+          # Both or one of them does not have a timestamp, 
+          # so we can't really compare them
+          raise CouchObject::Errors::CantCompareSize
+        end
+      else
+        raise CouchObject::Errors::CantCompareSize
+      end
+      
+    end
+    def <(other_object)
+      other_object > self
+    end
+
+    #
+    # <= and >= Uses the results from the methods ==, < and > 
+    # to determine the result
+    #
+    # Takes:
+    # * +other_object+ to compare size with
+    # 
+    # Raises:
+    # * CantCompareSize when trying to compare two object that have not
+    #   been saved or saved but do not have timestamps and that are not equal
+    #   
+    # Returns:
+    # * true or false
+    # 
+    def <=(other_object)
+      self == other_object || self < other_object ? true : false
+    end
+    def >=(other_object)
+      other_object <= self
+    end
+    
+    # 
+    # Returns a prettyfied string version of the object
+    # 
+    # def inspect
+    #       has_many_relations = []
+    # 
+    #       
+    #       has_many.each do |what_it_has|
+    #         related_objects = []
+    #         objects_it_has = self.send(what_it_has)
+    #         unless objects_it_has.size == 0
+    #           objects_it_has.each do |obj|
+    #             if obj.new?
+    #               related_objects << "<#{obj.class}[unsaved]>"
+    #             else
+    #               related_objects << "<#{obj.class}[#{obj.id}/#{obj.revision}]>"
+    #             end
+    #           end
+    #         end
+    #         
+    #         what_it_has_string = " #{what_it_has.to_s.capitalize}"
+    #         what_it_has_string += ": (#{related_objects.join(", ")})" \
+    #           unless related_objects.size == 0
+    # 
+    #         has_many_relations << what_it_has_string
+    #           
+    #       end
+    #       
+    #       has_many_string = ""
+    #       belongs_to_string = ""
+    #       
+    #       has_many_string = " Has many: #{has_many_relations.join(",")}" unless has_many_relations.size == 0
+    #       
+    #       if belongs_to
+    #         object_it_belongs_to = self.send(belongs_to)
+    #         if object_it_belongs_to
+    #           if object_it_belongs_to.new?
+    #             belongs_to_string = " Belongs to: " + \
+    #             "#{belongs_to.to_s.capitalize}" + \
+    #               "[unsaved]"
+    #           else
+    #             belongs_to_string = " Belongs to:" + \
+    #               " #{belongs_to.to_s.capitalize}" + \
+    #               "[#{object_it_belongs_to.id}/#{object_it_belongs_to.revision}]"          
+    #           end
+    #         end        
+    #       end
+    #       
+    #       if new?
+    #         "<#{self.class}[unsaved]#{belongs_to_string}#{has_many_string}>"
+    #       else
+    #         "<#{self.class}[#{self.id}/#{self.revision}]" + \
+    #           "#{belongs_to_string}#{has_many_string}>"
+    #       end
+    # 
+    #     end
+      end
+end

data/lib/couch_object/server.rb

@@ -3,7 +3,7 @@ require "net/http"
 module CouchObject
   class Server
     # Create a new Server object, +uri+ is the full URI of the server,
-    # eg. "http://localhost:8888"
+    # eg. "http://localhost:5984"
     def initialize(uri)
       @uri = URI.parse(uri)
       @host = @uri.host

data/lib/couch_object/utils.rb

@@ -9,5 +9,49 @@ module CouchObject
         end.join("/")
       end
     end
+    
+    def self.encode_querystring_parameter(parameter)
+      case parameter.class.to_s
+      when "Array"
+        # [12123,"ASD"] => [%2212123%22,%22ASD%22]
+        "[#{(parameter.map {|p| self.fix_parameter(p) }).join(",")}]"
+      else
+        self.fix_parameter(parameter)
+      end
+    end
+    
+    def self.decode_strings(input)
+      case input.class.to_s
+      when "String"
+        # HTMLEntities.decode_entities(input).toutf8
+        input.toutf8
+      when "Array"
+        input.map! do |n|
+          decode_strings(n)
+        end
+      when "Hash"
+        input.each_pair do |key, value|
+          input[key] = decode_strings(value)
+        end
+      else
+        input
+      end
+    end
+    
+    protected
+    def self.fix_parameter(p)      
+      case p.class.to_s.downcase
+      when "fixnum", "bignum", "trueclass", "falseclass"
+        "#{p.to_s}"
+      when "nilclass"
+        nil
+      else        
+        # Sanitize forward slashes
+        # # / => \/
+        val = p.gsub(/\//, "\\/")
+        "%22#{val}%22"
+      end      
+    end
+
   end
 end

data/lib/couch_object/version.rb

@@ -1,7 +1,7 @@
 module CouchObject #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 5
+    MINOR = 6
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')

data/lib/couch_object/view.rb

@@ -1,23 +1,146 @@
+require "net/http"
 require "enumerator"
 
 module CouchObject
   class View
+
+    # 
+    # Takes:
+    # * db as CouchObject::Database object or a string containing the database
+    #   uri and database name (http://localhost:5984/mydb)
+    # * name (string). The name of the view
+    # * query (JSON string). The JSON document that should be 
+    #   added to the database
+    # 
+    # Returns:
+    # CouchObject::Reponse object instance
+    # 
+    # Raises:
+    # * an exeption if it can't figure out the database
+    #     
     def self.create(db, name, query)
-      db.post("/#{db.name}/_view_#{name}", query)
+      _db = self.get_db(db)
+      # %2F => /
+      _db.put("_design%2F#{name}", query)
     end
-    
+
+    # 
+    # Takes:
+    # * db as CouchObject::Database object or a string containing the database
+    #   uri and database name (http://localhost:5984/mydb)
+    # * name (string). The name of the view
+    # 
+    # Returns:
+    # new CouchObject::View instance
+    # 
+    # Raises:
+    # * an exeption if it can't figure out the database
+    # 
     def initialize(db, name)
-      @db = db
+      @db = self.class.get_db(db)
       @name = name
     end
     attr_accessor :db
     
     def name
-      "_view_#{@name.dup}"
+      "_view/#{@name.dup}"
+    end
+    
+    #
+    # Returns an array of the rows returned by the view
+    # 
+    # Takes:
+    # * [+params+] (hash): a hash of URL query arguments supported
+    #   by couchDB. If omitted it defaults to not use a key 
+    #   and to update the view.
+    # 
+    #   Example:
+    # 
+    #     view.query({:update => false, :key => "bar"}) => Array
+    # 
+    # Returns:
+    # * a array of rows from the view
+    # 
+    # Raises:
+    # * CouchObject::Errors::MissingView if the view doesn't exist
+    # 
+    def query(params = {})
+
+      response = raw_query(params)
+      
+      rows_to_return = []
+      response["rows"].each do |params_for_object|
+          rows_to_return << params_for_object["value"]
+      end
+      
+      rows_to_return
+      
+    end
+
+    #
+    # Returns the response data from CouchDB for a view query without 
+    # 
+    # Takes:
+    # * [+params+] (hash): a hash of URL query arguments supported
+    #   by couchDB. If omitted it defaults to not use a key 
+    #   and to update the view.
+    # 
+    #   Example:
+    # 
+    #     view.raw_query({:update => false, :key => "bar"}) => data
+    # 
+    # Returns:
+    # * the response data for the view
+    # 
+    # Raises:
+    # * CouchObject::Errors::MissingView if the view doesn't exist
+    # 
+    def raw_query(params = {})
+
+      #Create a querystring with the parameters passed inn
+      querystring = "?"
+      params.each_pair do |key, value|
+        querystring += \
+          "#{key}=#{Utils.encode_querystring_parameter(value)}&"
+      end
+      querystring = querystring[0...-1]
+
+      view_with_parameters = name + querystring
+
+      response = JSON.parse(db.get(view_with_parameters).body)
+
+      raise CouchObject::Errors::MissingView, \
+        "The view '#{name}' doesn't exist on the server" \
+        if response["error"] == "not_found"
+
+      raise CouchObject::Errors::MapProcessError \
+        if response["error"] == "map_process_error"
+          
+      raise CouchObject::Errors::CouchDBError, \
+        "CouchDB returned and error and described the problem as #{response['reason']}" \
+        if response["error"]
+      
+      return response
+      
     end
     
     def delete
       @db.delete("/#{db.name}/#{name}")
     end
-  end
-end
+ 
+    protected
+    def self.get_db(db)
+     case db.class.to_s
+     when "CouchObject::Database"
+       db
+     when "String"
+       CouchObject::Database.open(db)
+     else
+       raise "You have to supply a database URI " + \
+         "or a CouchObject::Database object"        
+     end
+   end
+    
+ end
+end
+

data/spec/database_spec.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/spec_helper.rb'
 describe CouchObject::Database do
   before(:each) do
     @server = mock("Couch server")
-    @uri = "http://localhost:8888"
+    @uri = "http://localhost:5984"
     @response = mock("Net::HTTP::Response")
     CouchObject::Server.should_receive(:new).with(@uri).and_return(@server)
     @response.stub!(:code).and_return(200)
@@ -19,7 +19,7 @@ describe CouchObject::Database do
   
   it "should create a database" do
     @server.should_receive(:put).with("/foo", "").and_return(@response)
-    CouchObject::Database.create!(@uri, "foo")
+    CouchObject::Database.create(@uri, "foo")
   end
   
   it "should delete a database" do
@@ -49,7 +49,7 @@ describe CouchObject::Database do
   end
   
   it "should lint the database name from slashes with ::open" do
-    db = CouchObject::Database.open("http://localhost:8888/foo")
+    db = CouchObject::Database.open("http://localhost:5984/foo")
     class << db
       attr_accessor :dbname
     end
@@ -64,10 +64,16 @@ describe CouchObject::Database do
   
   it "should POST" do
     db = CouchObject::Database.new(@uri, "foo")        
-    @server.should_receive(:post).with("/foo/123", "postdata").and_return(@response)
+    @server.should_receive(:post).with("/foo/123", "postdata", "application/json").and_return(@response)
     db.post("123", "postdata")
   end
   
+  it "should POST with supplied ContentType header" do
+    db = CouchObject::Database.new(@uri, "foo")        
+    @server.should_receive(:post).with("/foo/123", "postdata", "text/rspec").and_return(@response)
+    db.post("123", "postdata", "text/rspec")
+  end
+  
   it "should PUT" do
     db = CouchObject::Database.new(@uri, "foo")        
     @server.should_receive(:put).with("/foo/123", "postdata").and_return(@response)
@@ -76,12 +82,12 @@ describe CouchObject::Database do
   
   it "should DELETE" do
     db = CouchObject::Database.new(@uri, "foo")        
-    @server.should_receive(:delete).with("/foo/123").and_return(@response)
-    db.delete("123")
+    @server.should_receive(:delete).with("/foo/123?rev=456").and_return(@response)
+    db.delete("123", "456")
   end
   
   it "should open a new connection from a full uri spec" do
-    proc{ CouchObject::Database.open("http://localhost:8888/foo") }.should_not raise_error
+    proc{ CouchObject::Database.open("http://localhost:5984/foo") }.should_not raise_error
   end
   
   it "should know the database name" do
@@ -91,7 +97,7 @@ describe CouchObject::Database do
   
   it "should know the full uri" do
     db = CouchObject::Database.new(@uri, "foo")
-    db.url.should == "http://localhost:8888/foo"    
+    db.url.should == "http://localhost:5984/foo"    
   end
   
   it "should load a document from id with #[]" do
@@ -142,31 +148,17 @@ describe CouchObject::Database do
   it "should store a document" do
     db = CouchObject::Database.new(@uri, "foo")
     doc = CouchObject::Document.new({"foo" => "bar"})
-    db.should_receive(:post).with("", JSON.unparse("foo" => "bar"))
+
+    FakeRespons = Struct.new(:to_document)
+    FakeDocument = Struct.new(:id, :revision)
+    document = \
+      FakeDocument.new("2113826070","id"=>"594F126A80B45C8AC2298E0393E20192")
+    response = FakeRespons.new(document)
+    
+    db.should_receive(:post).with("", JSON.unparse("foo" => "bar")).
+      and_return(response)
     db.store(doc)
   end
   
-  it "should return the rows when filtering" do
-    db = CouchObject::Database.new(@uri, "foo")
-    rowdata = { "_rev"=>1,
-                "_id"=>"1",
-                "value"=> {
-                  "_id"=>"1",
-                  "_rev"=>1,
-                  "foo"=>"bar"
-                }
-              }
-    resp = mock("response")
-    resp.stub!(:body).and_return(JSON.unparse("rows" => [rowdata]))
-    resp.stub!(:parse).and_return(resp)
-    resp.stub!(:to_document).and_return(
-      CouchObject::Document.new("rows" => [rowdata])
-    )
-    db.should_receive(:post).with("_temp_view", "proc { |doc|\n (doc[\"foo\"] == \"bar\")\n}").and_return(resp)
-    rows = db.filter{|doc| doc["foo"] == "bar"}
-    rows.size.should == 1
-    rows.first["value"]["foo"].should == "bar"
-  end
-  
   #it "should url encode paths"
 end