--- a/README.txt
+++ b/README.txt
@@ -635,4 +635,60 @@ CouchObject::Persistable performs callbacks by calling the following methods bef
                         "before_delete",
                         "after_delete"]
     
-	
\ No newline at end of file
+=== Smart save
+
+The way a CouchObject instance acts by default is to save itself and all
+its relatives regardless of if it needs to be saved or not when the +save+ 
+method is called.
+
+When activating smart save each instance contains a copy of its original
+state, and can, based on that, make smart decisions regarding wether or
+not it actually needs to save.
+
+Smart save should be used selectively though because keeping a copy of it's
+original state will increase the memory usage drastically for objects that
+contain a lot of data! There is also an overhead while initializing the
+object when the state is created, although that will in most cases be 
+rather insignificant. These factors add up quickly though if you are working
+with many objects at the same time.
+
+Smart save can either be defined in the class definition:
+
+	class SmartClass
+	  include CouchObject::Persistable
+	  smart_save
+	end
+	
+	instance_with_smart_save_activated = SmartClass.get("foo")
+
+where all instances will receive the smart saving feature by default,
+or it can be toggled manually:
+
+	class NotSoSmartClass
+	  include CouchObject::Persistable
+	end
+	
+	instance_WITHOUT_smart_save_activated = NotSoSmartClass.get("foo")
+
+	NotSoSmartClass.smart_save
+	
+	instance_WITH_smart_save_activated = NotSoSmartClass.get("bar")
+
+	NotSoSmartClass.deactivate_smart_save
+	
+	instance_WITHOUT_smart_save_activated_2 = NotSoSmartClass.get("dong")
+
+The same as in the example above can be achieved with the convenience 
+method +get_with_smart_save+ which takes the same parameters as +get_by_id+.
+The same example could therefor also be written as:
+
+	class NotSoSmartClass
+	  include CouchObject::Persistable
+	end
+
+	instance_WITHOUT_smart_save_activated = NotSoSmartClass.get("foo")
+
+	instance_WITH_smart_save_activated = NotSoSmartClass.get_with_smart_save("bar")
+
+	instance_WITHOUT_smart_save_activated_2 = NotSoSmartClass.get("dong")
+

--- a/lib/couch_object.rb
+++ b/lib/couch_object.rb
@@ -11,7 +11,13 @@ rescue LoadError
 end
 
 require 'json/add/core'
-require "ruby2ruby"
+require 'thread'
+
+# require "ruby2ruby" Is used by the ruby view server which is to be moved out of the gem
+# require "htmlentities" # if you want the UTILS::decode_strings to 
+                         # replace characters like ø with ø
+                         # then this has to be included...
+require "kconv" # To convert all input to UTF-8 before it is made to_json
 
 $:.unshift File.dirname(__FILE__)
 

--- a/lib/couch_object/persistable.rb
+++ b/lib/couch_object/persistable.rb
@@ -11,8 +11,8 @@
 #
 # = TODOs and known issues:
 # 
-# * TODO: Create a way to check if an object has unsaved changes or not and 
-#   make it check that itself before saving
+# * TODO: create a way to solve saving conflicts. Should also be possible 
+#   to chose if only conflicts for certain variables should be handled.
 # 
 # * TODO: If real world usage shows that it is needed then create a reload method
 #   that reloads the content from the db. Might be useful if some other 
@@ -104,7 +104,7 @@ module CouchObject
         end
                 
         # creates a new object and initialize all its sub objects
-        new_object = coach_load_object(response)
+        new_object = couch_load_object(response)
         
         # set the storage location it was loaded from so it can be saved 
         # back directly without having to supply the db_uri again
@@ -119,6 +119,25 @@ module CouchObject
       # 
       alias get get_by_id
 
+      # 
+      # Takes, returns and raises the same things as +get_by_id+
+      # 
+      # Creates a new object that is forced into smart save mode
+      # although the class it is stemming from might not have smart
+      # saving enabled.
+      # 
+      def get_with_smart_save(id, db_uri = self.location)
+        
+        new_object = self.get_by_id(id, db_uri)
+
+        # Force it into smart save mode
+        new_object.couch_force_smart_save
+        
+        # Initialize the original state.
+        new_object.couch_set_initial_state
+        
+        new_object
+      end
       
       #
       # Loads all document from a given view from the database
@@ -182,7 +201,7 @@ module CouchObject
           if response["error"]
         
         response["rows"].each do |params_for_object|
-          objects_to_return << coach_load_object(params_for_object["value"])
+          objects_to_return << couch_load_object(params_for_object["value"])
         end
         
         objects_to_return
@@ -203,7 +222,7 @@ module CouchObject
       # Raises:
       # * Does currently not raise any error
       # 
-      def coach_load_object(parameters)
+      def couch_load_object(parameters)
 
         # Getting the values that shouldn't be passed on to the initializer
         id = parameters["_id"]
@@ -232,7 +251,7 @@ module CouchObject
                 parameters["attributes"][key]["class"] != nil
 
                 new_object_from_couch.instance_variable_set("@#{key}", \
-                  self.coach_load_object(parameters["attributes"][key]))
+                  self.couch_load_object(parameters["attributes"][key]))
               else
                 # Add the value to the class
                 new_object_from_couch.
@@ -261,6 +280,7 @@ module CouchObject
           instance_variable_set("@belongs_to", belongs_to) \
           if belongs_to
         
+        new_object_from_couch.couch_set_initial_state
                 
         # Returns the new object
         new_object_from_couch
@@ -288,6 +308,32 @@ module CouchObject
       id.nil? || revision.nil?
     end
     
+    # 
+    # Stores the initial value of the instance to a variable
+    # for later reference by the +unsaved_changes?+ method
+    # 
+    def couch_set_initial_state
+      # For the unsaved_changes? instance method to work, we have to
+      # supply a snapshot of what the fresh object looked like.
+      # BUT ONLY if the user has activated the smart_save option
+      if use_smart_save
+
+        @couch_initial_load = true
+        @couch_object_original_state = to_json
+        @couch_initial_load = false
+        
+      end
+    end
+
+    # 
+    # Forces the instance object into smart save mode
+    # 
+    def couch_force_smart_save
+      def self.use_smart_save
+        true
+      end
+    end 
+    
     #
     # Saves the object to the db_uri supplied, or if not set, to the 
     # location the object has previously been saved to.
@@ -318,8 +364,18 @@ module CouchObject
       # If it's belongs_to relationships haven't been saved
       # then it has be done first.
       # Saving the master will also automatically save the child
-
       performed_save = false
+      
+      # If the belongs_to relationships haven't already been loaded,
+      # there is reason to believe that:
+      # * The object is new and doesn't have any relation set
+      # * The object already knows about it's belongs_to relations
+      #   and doesn't need aditional information about them for saving
+      # We therefore deactivate the loading of belongs_to relations
+      original_state_of_load_belongs_to_relations = \
+        @do_not_load_belongs_to_relations
+      @do_not_load_belongs_to_relations = true
+      
       belongs_to.each do |what_it_belongs_to|
         master_class = self.send(what_it_belongs_to)
         unless master_class == nil || !master_class.new?
@@ -328,6 +384,11 @@ module CouchObject
         end
       end
         
+      # Reset the do_not_load_belongs_to_relations variable to its 
+      # original state
+      @do_not_load_belongs_to_relations = \
+        original_state_of_load_belongs_to_relations
+      
       # If none of the master classes were saved, meaning they weren't new
       # or didn't exist, then we have to manually save this object.
       couch_perform_save unless performed_save
@@ -349,11 +410,17 @@ module CouchObject
       state_before_wants_to_load_relations = @do_not_load_has_many_relations
       @do_not_load_has_many_relations = true
       
+      # We thread the save process in case the relations do
+      # some funky time consuming stuff in their call backs
+      threads = []
       has_many.each do |thing_it_has_many_of|
         self.send(thing_it_has_many_of).each do |related_object|
-          related_object.save(location)
+          threads << Thread.new(related_object) do |object_to_save|
+            object_to_save.save(location)
+          end
         end
       end
+      threads.each {|thr| thr.join}
       
       # Save all the has_one relations
       has_one.each do |thing_it_has_one_of|
@@ -367,7 +434,7 @@ module CouchObject
       # Reset the do_not_load_has_many_relations variable
       # to it's original state
       @do_not_load_has_many_relations = state_before_wants_to_load_relations
-                  
+               
       perform_callback(:after_save)
             
       return the_return_value
@@ -387,7 +454,9 @@ module CouchObject
       
       db = CouchObject::Database.open(location)
       
-      unless (response = db.post("", self.to_json)).to_document["error"]
+      json_value = self.to_json
+      
+      unless (response = db.post("", json_value)).to_document["error"]
         response_document = response.to_document
         @id = response_document.id
         @revision = response_document.revision
@@ -396,6 +465,10 @@ module CouchObject
         @updated_at = Time.now if self.
           class::couch_object_timestamp_on_update?     
         
+        # If the user has activated smart_save, we should set the state 
+        # to the new contents of this instance!
+        @couch_object_original_state = json_value if use_smart_save
+        
         perform_callback(:after_create)
         
         # Returns a hash with the ID and Revision
@@ -403,7 +476,8 @@ module CouchObject
 
       else
 
-        raise CouchObject::Errors::DatabaseSaveFailed, "The document couldn't be created.\n" + \
+        raise CouchObject::Errors::DatabaseSaveFailed, "The document " + \
+          "couldn't be created.\n" + \
           "CouchDB reported: #{response.to_document["error"]}"
       
       end
@@ -420,38 +494,77 @@ module CouchObject
     # 
     def couch_update
       
-      perform_callback(:before_update)
-      
-      # Please notice the following:
-      # The response from CouchDB only includes the revision number
-      # and the ID so the updated_at value in the document store
-      # differs from the updated_at value in the class
-      @updated_at = Time.now if self.
-        class::couch_object_timestamp_on_update?
+      # Only save if it has unsaved changes!
+      if unsaved_changes?
 
-      db = CouchObject::Database.open(location)
-      
-      unless (response = db.put(id, self.to_json)).to_document["error"]
+        perform_callback(:before_update)
 
-        @revision = response.to_document.revision
+        # Please notice the following:
+        # The response from CouchDB only includes the revision number
+        # and the ID so the updated_at value in the document store
+        # differs from the updated_at value in the class
+        @updated_at = Time.now if self.
+          class::couch_object_timestamp_on_update?
 
-        perform_callback(:after_update)
+        db = CouchObject::Database.open(location)
 
-        # Returns a hash with the ID and Revision
-        {:id => @id, :revision => @revision}
-      
-      else
+        json_value = self.to_json
+
+        unless (response = db.put(id, json_value)).to_document["error"]
+
+          @revision = response.to_document.revision
+
+          # If the user has activated smart_save, we should set the state 
+          # to the new contents of this instance!
+          @couch_object_original_state = json_value if use_smart_save
+
+          perform_callback(:after_update)
+
+          # Returns a hash with the ID and Revision
+          {:id => @id, :revision => @revision}
 
-        raise CouchObject::Errors::DatabaseSaveFailed, "The document couldn't be updated.\n" + \
-          "The reason might be a revision number conflict.\n" + \
-          "CouchDB reported: #{response.to_document["reason"]}"          
+        else
+
+          raise CouchObject::Errors::DatabaseSaveFailed, "The document " + \
+            "couldn't be updated.\n" + \
+            "The reason might be a revision number conflict.\n" + \
+            "CouchDB reported: #{response.to_document["reason"]}"          
+
+        end
         
+      
       end
+
     end
     
-    
+  
     public
     # 
+    # Classes WITH smart_save activated:
+    # Any instance should be able to know if it has unsaved changes or not.
+    # When an instance is loaded from the DB it creates a snapshot of what
+    # its variables contain. Based on a comparison between the snapshot
+    # and the contents of the instance this method returns true or false.
+    # 
+    # Classes WITHOUT smart_save activated:
+    # Will always return true regardless of what state it is in
+    # 
+    # A new object will always return true
+    # 
+    # Returns:
+    # * true: if it has changes that haven't been saved to the database
+    # * fase: if the nothing has changed since it was loaded from the 
+    #   database.
+    # 
+    def unsaved_changes?
+      return true if new?
+      return true unless use_smart_save
+      
+      @couch_object_original_state == self.to_json ? false : true
+      
+    end
+
+    # 
     # Any instance should be able to delete itself
     # 
     # Takes:
@@ -572,7 +685,11 @@ module CouchObject
                                      "@updated_at",
                                      "@id",
                                      "@revision",
-                                     "@do_not_load_has_many_relations"]
+                                     "@do_not_load_has_many_relations",
+                                     "@do_not_load_belongs_to_relations",
+                                     "@couch_object_original_state",
+                                     "@couch_initial_load",
+                                     "@belongs_to"]
         
         # We also have to remove all the objects that are related
         # through belongs_to and has_many relations. They have to be called
@@ -608,23 +725,88 @@ module CouchObject
       
       # If it is in belongs_to relationship(s), then that fact 
       # has to be stored in the database
-      unless belongs_to == []
+      if belongs_to != [] and !@couch_initial_load # the couch_initial_load
+                                                   # is to get the initial
+                                                   # state of the object
+                                                   # without loading the
+                                                   # belongs_to relations
+                                                   # which would start an
+                                                   # infinite loop.
+                                                   # NOTE: this is only for
+                                                   # cases where smart_save
+                                                   # has been activated.
+        
+        # No reason to load the belongs_to relations if they haven't
+        # already been loaded from the database!
+        original_state_of_load_belongs_to_relations = \
+          @do_not_load_belongs_to_relations
+        @do_not_load_belongs_to_relations = true
+    
         what_it_belongs_to = {}
         self.send(:belongs_to).each do |relation|
           as_what = self.send("belongs_to_#{relation}_as")
           object_it_belongs_to = self.send(relation)
-
+      
           # Unless the relation is unset, in which case it will be of
           # type NilClass, set it.
-          what_it_belongs_to[as_what] = object_it_belongs_to.id \
+          what_it_belongs_to[as_what.to_s] = object_it_belongs_to.id || "new" \
             unless object_it_belongs_to.class == NilClass
         end
-        parameters["belongs_to"] = what_it_belongs_to
+        
+        # Reset the value so they are loaded the next time when needed
+        # if that is what the user wants.
+        @do_not_load_belongs_to_relations = \
+          original_state_of_load_belongs_to_relations
+
+
+        # We have to make sure the @belongs_to variable contains all changes
+        # and all the original values for the keys that haven't changed/
+        # relations that haven't been loaded
+        original_belongs_to = @belongs_to || {}
+        @belongs_to = what_it_belongs_to
+        times_through = 1
+
+        # LOOP 1... see below for problem description
+        original_belongs_to.each_pair do |key, value|
+          times_through += 1
+          @belongs_to[key.to_s] = value unless @belongs_to[key.to_s]
+        end
+
+        # FIXME:
+        # Now... this is a really hacky way to solve this problem
+        # and should be improved... Feel free to come up with sollutions
+        # Case:
+        # If it has a belongs_to relationship that is new and therefore 
+        # doesn't have an ID it would normally be written in the @belongs_to 
+        # variable as nil. The problem is that if self has previously
+        # been saved with another parent object this ID would still come
+        # through in the @belongs_to variable updater (see "LOOP 1" above).
+        # We therefore assign the ID "new" to all unsaved relations, which we
+        # now have to nilify. If we don't the smart save wont work for this 
+        # type of cases.
+
+      end
+      
+      parameters["belongs_to"] = @belongs_to 
+      parameters.delete("belongs_to") if @belongs_to == {} or @belongs_to == nil
+
+       # if @couch_initial_load && @belongs_to
+      
+      begin
+        parameters.to_json
+      rescue JSON::GeneratorError
+        # All strings aren't encoded properly, so we have to force them into
+        # UTF-8. 
+        # FIXME: The kconv library has some weird artefacts though where
+        # a lot of Norwegian (Scandianavian?) letters get turned into
+        # asian characters of some sort!
+        CouchObject::Utils::decode_strings(parameters).to_json  
       end
       
-      parameters.to_json
     end
     
+
+    
     # 
     # Sometimes you might want to add an object to 
     # a has_many relation without interacting with the other relations at all.
@@ -638,6 +820,26 @@ module CouchObject
     def do_load_has_many_relations  
       @do_not_load_has_many_relations = false
     end
+    alias do_not_load_has_one_relations do_not_load_has_many_relations
+    alias do_load_has_one_relations do_load_has_many_relations
+    alias do_not_load_has_one_relation do_not_load_has_many_relations
+    alias do_load_has_one_relation do_load_has_many_relations
+
+    # 
+    # If you need to access the belongs_to variable without loading the
+    # relation if it hasn't already been loaded, you can call the instance
+    # method +do_not_load_belongs_to_relations+. To reactivate loading so
+    # the relation is loaded the next time it is needed, call the instance 
+    # method +do_load_belongs_to_relations+.
+    #
+    def do_not_load_belongs_to_relations
+      @do_not_load_belongs_to_relations = true
+    end
+    def do_load_belongs_to_relations
+      @do_not_load_belongs_to_relations = false
+    end
+    alias do_not_load_has_many_relation do_not_load_has_many_relations
+    alias do_load_belongs_to_relation do_load_belongs_to_relations
 
     
     protected
@@ -697,7 +899,7 @@ module CouchObject
             
         db = CouchObject::Database.open(location)
         
-        if (response = db.put("_design/#{view_name}/#{view_name}", \
+        if (response = db.put("_design%2F#{view_name}", \
             view_code_query))
           results = couch_load_has_many_relations(which_relation)
         else
@@ -714,6 +916,8 @@ module CouchObject
     # 
     def couch_load_belongs_to_relation(that_is_called)
       
+      return nil if new? || @do_not_load_belongs_to_relations
+      
       # If it doesn't have a belongs to ID then there is no
       # related object in the database
       if @belongs_to && @belongs_to[that_is_called]

--- a/lib/couch_object/persistable/meta_classes.rb
+++ b/lib/couch_object/persistable/meta_classes.rb
@@ -115,6 +115,55 @@ module CouchObject
 
 
         ##
+        # Smart savign
+        ##
+        
+        def use_smart_save; false; end
+        # 
+        # Smart save (defaults to false), if activated, keeps a snapshot of
+        # the objects initial state and evaluates if the class needs to be
+        # saved to the database by comparing it to the snapshot when a save
+        # is requested.
+        # 
+        # Please notice:
+        # Only activate this feature in cases where it is needed.
+        # It might slow down the performance of your app if you activate it
+        # for classes that you need many instances of and that you won't 
+        # call the save method on after having loaded them from the database.
+        # Please also bare in mind that the class instance will store an 
+        # extra copy of its contents which will lead to quite a big memory
+        # overhead for classes that store a lot of data!
+        #         
+        def self.smart_save
+          self.instance_eval do
+            define_method("use_smart_save")