README.md in data_cleansing-0.6.0 vs README.md in data_cleansing-0.6.1

@@ -20,25 +20,25 @@
 or pull request.
 
 ## Features
 
 * Supports global cleansing definitions that can be associated with any Ruby,
-  Rails, Mongoid, or other model.
-* Supports custom cleansing definitions that can be defined in-line using block.
-* A cleansing block can access the other attributes in the model in determining
-  how to cleanse the current attribute
-* In a cleansing block other can also be modified if necessary
+  Rails, Mongoid, or other model
+* Supports custom cleansing definitions that can be defined in-line
+* A cleansing block can access the other attributes in the model while cleansing
+  the current attribute
+* In a cleansing block other attributes in the model can be modified at the
+  same time
 * Cleansers are executed in the order they are defined. As a result multiple
   cleansers can be run against the same field and the order is preserved
 * Multiple cleansers can be specified for a list of attributes at the same time
 * Inheritance is supported. The cleansers for parent classes are run before
   the child's cleansers
 * Cleansers can be called outside of a model instance for cases where fields
   need to be cleansed before the model is created, or needs to be found
-* Logging of data cleansing with the before and after values for troubleshooting.
-  Depending on the log level all modified fields are logged, or just the ones
-  completely wiped out to nil
+* To aid troubleshooting the before and after values of cleansed attributes
+  is logged. The level of detail is fine-tuned using the log level
 
 ## ActiveRecord (ActiveModel) Features
 
 * Passes the value of the attribute before the Rails type cast so that the
   original text can be cleansed before passing back to rails for type conversion.
@@ -65,15 +65,15 @@
 
 u = User.new
 u.first_name = '    joe   '
 u.last_name = "\n  black\n"
 puts "Before data cleansing #{u.inspect}"
-# Before data cleansing Before data cleansing #<User:0x007fc9f1081980 @first_name="    joe   ", @last_name="\n  black\n">
+# Before data cleansing #<User:0x007fc9f1081980 @first_name="    joe   ", @last_name="\n  black\n">
 
 u.cleanse_attributes!
 puts "After data cleansing #{u.inspect}"
-# After data cleansing After data cleansing #<User:0x007fc9f1081980 @first_name="joe", @last_name="black">
+# After data cleansing #<User:0x007fc9f1081980 @first_name="joe", @last_name="black">
 ```
 
 ### Rails Example
 
 ```ruby
@@ -152,10 +152,68 @@
 u.cleanse_attributes!
 puts "After data cleansing #{u.inspect}"
 # After data cleansing #<User:0x007fdd5a83a8f8 @first_name="joe", @last_name="black", @address1="2632 Brown St", @title="MR.", @gender="Male">
 ```
 
+## After Cleansing
+
+It is sometimes useful to read or write multiple fields as part of a cleansing, or
+where attributes need to be manipulated automatically once they have been cleansed.
+For this purpose instance methods on the model can be registered for invocation once
+all the attributes have been cleansed according to their :cleanse specifications.
+Multiple methods can be registered and they are called in the order they are registered.
+
+```ruby
+after_cleanse <instance_method_name>, <instance_method_name>, ...
+```
+
+Example:
+```ruby
+# Define a global cleanser
+DataCleansing.register_cleaner(:strip) {|string| string.strip}
+
+# 'users' table has the following columns :first_name, :last_name, :address1, :address2
+class User < ActiveRecord::Base
+  include DataCleansing::Cleanse
+
+  # Use a global cleaner
+  cleanse :first_name, :last_name, :cleaner => :strip
+
+  # Define a once off cleaner
+  cleanse :address1, :address2, :cleaner => Proc.new {|string| string.strip}
+
+  # Once the above cleansing is complete call the instance method
+  after_cleanse :check_address
+
+  protected
+
+  # Method to be called once data cleansing is complete
+  def check_address
+    # Move address2 to address1 if Address1 is blank and address2 has a value
+    address2 = address1 if address1.blank? && !address2.blank?
+  end
+
+end
+
+# Create a User instance
+u = User.new(:first_name => '    joe   ', :last_name => "\n  black\n", :address2 => "2632 Brown St   \n")
+puts "Before data cleansing #{u.attributes.inspect}"
+u.cleanse_attributes!
+puts "After data cleansing #{u.attributes.inspect}"
+u.save!
+```
+
+## Recommendations
+
+:data_cleanse block are ideal for cleansing a single attribute, and applying any
+global or common cleansing algorithms.
+
+Even though multiple attributes can be read or written in a single :data_cleanse
+block, it is recommended to use the :after_cleanse method for working with multiple
+attributes. It is much easier to read and understand the interactions between multiple
+attributes in the :after_cleanse methods.
+
 ## Rails configuration
 
 When DataCleansing is used in a Rails environment it can be configured using the
 regular Rails configuration mechanisms. For example:
 
@@ -194,37 +252,46 @@
 ```ruby
 SemanticLogger.default_level = Rails.logger.level
 SemanticLogger.add_appender(Rails.logger)
 ```
 
-By changing the log level for DataCleansing the type of output for data
+By changing the log level of DataCleansing itself the type of output for data
 cleansing can be controlled:
 
 * :trace or :debug to log all fields modified
 * :info to log only those fields which were nilled out
 * :warn or higher to disable logging of cleansing actions
 
+Note:
+
+* The logging of changes made to attributes only includes attributes cleansed
+  with :data_cleanse blocks. Attributes modified within :after_cleanse methods
+  are not logged
+
+* It is not necessary to change the global log level to affect the logging detail
+  level in DataCleansing. DataCleansing log level is changed independently
+
 To change the log level, either use the Rails configuration approach, or set it
 directly:
 
 ```ruby
 DataCleansing.logger.level = :info
 ```
 
 ## Notes
 
-Cleaners are called in the order in which they are defined, so subsequent cleaners
-can assume that the previous cleaners have run and can therefore access or even
-modify previously cleaned attributes
+* Cleaners are called in the order in which they are defined, so subsequent cleaners
+  can assume that the previous cleaners have run and can therefore access or even
+  modify previously cleaned attributes
 
 ## Installation
 
 ### Add to an existing Rails project
 
 Add the following line to Gemfile
 
 ```ruby
-gem 'data_validation'
+gem 'data_cleansing'
 ```
 
 Install the Gem with bundler
 
     bundle install