diff --git a/app/models/article.rb b/app/models/article.rb
index 9f6343c..93a8b86 100644
--- a/app/models/article.rb
+++ b/app/models/article.rb
@@ -147,7 +147,7 @@ class Article < ActiveRecord::Base
     self.profile
   end
 
-  def self.human_attribute_name(attrib)
+  def self.human_attribute_name(attrib, options = {})
     case attrib.to_sym
     when :name
       _('Title')
diff --git a/app/models/person.rb b/app/models/person.rb
index 28985f1..b769434 100644
--- a/app/models/person.rb
+++ b/app/models/person.rb
@@ -158,8 +158,9 @@ class Person < Profile
     FIELDS
   end
 
-  def validate
-    super
+  validate :presence_of_required_fields
+
+  def presence_of_required_fields
     self.required_fields.each do |field|
       if self.send(field).blank?
         unless (field == 'custom_area_of_study' && self.area_of_study != 'Others') || (field == 'custom_formation' && self.formation != 'Others')
diff --git a/app/models/task.rb b/app/models/task.rb
index 9223d65..555d4b2 100644
--- a/app/models/task.rb
+++ b/app/models/task.rb
@@ -235,6 +235,29 @@ class Task < ActiveRecord::Base
     end
   end
 
+  scope :pending, :conditions => { :status =>  Task::Status::ACTIVE }
+  scope :hidden, :conditions => { :status =>  Task::Status::HIDDEN }
+  scope :finished, :conditions => { :status =>  Task::Status::FINISHED }
+  scope :canceled, :conditions => { :status =>  Task::Status::CANCELLED }
+  scope :closed, :conditions => { :status =>  [Task::Status::CANCELLED, Task::Status::FINISHED] }
+  scope :opened, :conditions => { :status =>  [Task::Status::ACTIVE, Task::Status::HIDDEN] }
+  scope :of, lambda { |type| conditions = type ? "type LIKE '#{type}'" : "1=1"; {:conditions =>  [conditions]} }
+  scope :order_by, lambda { |attribute, ord| {:order => "#{attribute} #{ord}"} }
+
+  scope :to, lambda { |profile|
+    environment_condition = nil
+    if profile.person?
+      envs_ids = Environment.find(:all).select{ |env| profile.is_admin?(env) }.map { |env| "target_id = #{env.id}"}.join(' OR ')
+      environment_condition = envs_ids.blank? ? nil : "(target_type = 'Environment' AND (#{envs_ids}))"
+    end
+    profile_condition = "(target_type = 'Profile' AND target_id = #{profile.id})"
+    { :conditions => [environment_condition, profile_condition].compact.join(' OR ') }
+  }
+
+  def opened?
+    status == Task::Status::ACTIVE || status == Task::Status::HIDDEN
+  end
+
   protected
 
   # This method must be overrided in subclasses, and its implementation must do
@@ -266,29 +289,6 @@ class Task < ActiveRecord::Base
     end
   end
 
-  scope :pending, :conditions => { :status =>  Task::Status::ACTIVE }
-  scope :hidden, :conditions => { :status =>  Task::Status::HIDDEN }
-  scope :finished, :conditions => { :status =>  Task::Status::FINISHED }
-  scope :canceled, :conditions => { :status =>  Task::Status::CANCELLED }
-  scope :closed, :conditions => { :status =>  [Task::Status::CANCELLED, Task::Status::FINISHED] }
-  scope :opened, :conditions => { :status =>  [Task::Status::ACTIVE, Task::Status::HIDDEN] }
-  scope :of, lambda { |type| conditions = type ? "type LIKE '#{type}'" : "1=1"; {:conditions =>  [conditions]} }
-  scope :order_by, lambda { |attribute, ord| {:order => "#{attribute} #{ord}"} }
-
-  scope :to, lambda { |profile|
-    environment_condition = nil
-    if profile.person?
-      envs_ids = Environment.find(:all).select{ |env| profile.is_admin?(env) }.map { |env| "target_id = #{env.id}"}.join(' OR ')
-      environment_condition = envs_ids.blank? ? nil : "(target_type = 'Environment' AND (#{envs_ids}))"
-    end
-    profile_condition = "(target_type = 'Profile' AND target_id = #{profile.id})"
-    { :conditions => [environment_condition, profile_condition].compact.join(' OR ') }
-  }
-
-  def opened?
-    status == Task::Status::ACTIVE || status == Task::Status::HIDDEN
-  end
-
   class << self
 
     # generates a random code string consisting of length characters (or 36 by
diff --git a/test/unit/person_test.rb b/test/unit/person_test.rb
index 65495b2..ed9b918 100644
--- a/test/unit/person_test.rb
+++ b/test/unit/person_test.rb
@@ -5,7 +5,7 @@ class PersonTest < ActiveSupport::TestCase
   fixtures :profiles, :users, :environments
 
   def test_person_must_come_form_the_cration_of_an_user
-    p = Person.new(:environment => Environment.default, :name => 'John', :identifier => 'john')
+    p = build(Person, :environment => Environment.default, :name => 'John', :identifier => 'john')
     assert !p.valid?
     p.user =  create_user('john', :email => 'john@doe.org', :password => 'dhoe', :password_confirmation => 'dhoe')
     assert !p.valid?
@@ -14,22 +14,22 @@ class PersonTest < ActiveSupport::TestCase
   end
 
   def test_can_associate_to_a_profile
-    pr = Profile.new(:identifier => 'mytestprofile', :name => 'My test profile')
+    pr = build(Profile, :identifier => 'mytestprofile', :name => 'My test profile')
     pr.save!
     pe = create_user('person', :email => 'person@test.net', :password => 'dhoe', :password_confirmation => 'dhoe').person
     pe.save!
-    member_role = Role.create(:name => 'somerandomrole')
+    member_role = create(Role, :name => 'somerandomrole')
     pr.affiliate(pe, member_role)
 
     assert pe.memberships.include?(pr)
   end
 
   def test_can_belong_to_an_enterprise
-    e = Enterprise.new(:identifier => 'enterprise', :name => 'enterprise')
+    e = build(Enterprise, :identifier => 'enterprise', :name => 'enterprise')
     e.save!
     p = create_user('person', :email => 'person@test.net', :password => 'dhoe', :password_confirmation => 'dhoe').person
     p.save!
-    member_role = Role.create(:name => 'somerandomrole')
+    member_role = create(Role, :name => 'somerandomrole')
     e.affiliate(p, member_role)
 
     assert p.memberships.include?(e)
@@ -46,7 +46,7 @@ class PersonTest < ActiveSupport::TestCase
   end
 
   should 'be associated with a user' do
-    u = User.new(:login => 'john', :email => 'john@doe.org', :password => 'dhoe', :password_confirmation => 'dhoe')
+    u = build(User, :login => 'john', :email => 'john@doe.org', :password => 'dhoe', :password_confirmation => 'dhoe')
     u.save!
     assert_equal u, Person['john'].user
   end
@@ -57,21 +57,21 @@ class PersonTest < ActiveSupport::TestCase
     p1 = u.person
     assert_equal u, p1.user
     
-    p2 = Person.new(:environment => Environment.default)
+    p2 = build(Person, :environment => Environment.default)
     p2.user = u
     assert !p2.valid?
     assert p2.errors[:user_id.to_s].present?
   end
 
   should "have person info fields" do
-    p = Person.new(:environment => Environment.default)
+    p = build(Person, :environment => Environment.default)
     [ :name, :photo, :contact_information, :birth_date, :sex, :address, :city, :state, :country, :zip_code, :image, :district, :address_reference ].each do |i|
       assert_respond_to p, i
     end
   end
 
   should 'not have person_info class' do
-    p = Person.new(:environment => Environment.default)
+    p = build(Person, :environment => Environment.default)
     assert_raise NoMethodError do
       p.person_info
     end
@@ -80,9 +80,9 @@ class PersonTest < ActiveSupport::TestCase
   should 'change the roles of the user' do
     p = create_user('jonh', :email => 'john@doe.org', :password => 'dhoe', :password_confirmation => 'dhoe').person
     e = fast_create(Enterprise)
-    r1 = Role.create(:name => 'associate')
+    r1 = create(Role, :name => 'associate')
     assert e.affiliate(p, r1)
-    r2 = Role.create(:name => 'partner')
+    r2 = create(Role, :name => 'partner')
     assert p.define_roles([r2], e)
     p = Person.find(p.id)
     assert p.role_assignments.any? {|ra| ra.role == r2}
@@ -91,7 +91,7 @@ class PersonTest < ActiveSupport::TestCase
 
   should 'report that the user has the permission' do
     p = create_user('john', :email => 'john@doe.org', :password => 'dhoe', :password_confirmation => 'dhoe').person
-    r = Role.create(:name => 'associate', :permissions => ['edit_profile'])
+    r = create(Role, :name => 'associate', :permissions => ['edit_profile'])
     e = fast_create(Enterprise)
     assert e.affiliate(p, r)
     p = Person.find(p.id)
@@ -106,7 +106,7 @@ class PersonTest < ActiveSupport::TestCase
   end
 
   should 'get no email address when there is no associated user' do
-    p = Person.new(:environment => Environment.default)
+    p = build(Person, :environment => Environment.default)
     assert_nil p.email
   end
 
@@ -134,7 +134,7 @@ class PersonTest < ActiveSupport::TestCase
     other.email = 'user@domain.com'
     other.valid?
     assert other.errors[:email.to_s].present?
-    assert_no_match /\{fn\}/, other.errors.on(:email)
+    assert_no_match /\{fn\}/, other.errors[:email].first
   end
 
   should 'be able to use an e-mail already used in other environment' do
@@ -148,7 +148,7 @@ class PersonTest < ActiveSupport::TestCase
   end
 
   should 'be an admin if have permission of environment administration' do
-    role = Role.create!(:name => 'just_another_admin_role')
+    role = create(Role, :name => 'just_another_admin_role')
     env = fast_create(Environment)
     person = create_user('just_another_person').person
     env.affiliate(person, role)
@@ -163,7 +163,7 @@ class PersonTest < ActiveSupport::TestCase
     env2 = fast_create(Environment)
 
     # role is an admin role
-    role = Role.create!(:name => 'just_another_admin_role')
+    role = create(Role, :name => 'just_another_admin_role')
     role.update_attributes(:permissions => ['view_environment_admin_panel'])
 
     # user is admin of env1, but not of env2
@@ -176,15 +176,16 @@ class PersonTest < ActiveSupport::TestCase
   end
 
   should 'create a default set of articles' do
-    Person.any_instance.stubs(:default_set_of_articles).returns([Blog.new(:name => 'blog')])
-    person = create_user_full('mytestuser').person
+    blog = build(Blog)
+    Person.any_instance.stubs(:default_set_of_articles).returns([blog])
+    person = create(User).person
 
-    assert_kind_of Blog, person.articles.find_by_path('blog')
-    assert_kind_of RssFeed, person.articles.find_by_path('blog/feed')
+    assert_kind_of Blog, person.articles.find_by_path(blog.path)
+    assert_kind_of RssFeed, person.articles.find_by_path(blog.feed.path)
   end
 
   should 'create a default set of blocks' do
-    p = create_user_full('testingblocks').person
+    p = create(User).person
 
     assert !p.boxes[0].blocks.empty?, 'person must have blocks in area 1'
     assert !p.boxes[1].blocks.empty?, 'person must have blocks in area 2'
@@ -192,7 +193,7 @@ class PersonTest < ActiveSupport::TestCase
   end
 
   should 'link to all articles created by default' do
-    p = create_user_full('testingblocks').person
+    p = create(User).person
     blocks = p.blocks.select { |b| b.is_a?(LinkListBlock) }
     p.articles.reject { |a| a.is_a?(RssFeed) }.each do |article|
       path = '/' + p.identifier + '/' + article.path
@@ -213,22 +214,21 @@ class PersonTest < ActiveSupport::TestCase
     p1.add_friend(p3)
 
     assert_equal [p2,p3], p1.friends(true) # force reload
-
   end
 
   should 'suggest default friend groups list' do
-    p = Person.new(:environment => Environment.default)
+    p = build(Person, :environment => Environment.default)
     assert_equivalent [ 'friends', 'work', 'school', 'family' ], p.suggested_friend_groups
   end
 
   should 'suggest current groups as well' do
-    p = Person.new(:environment => Environment.default)
+    p = build(Person, :environment => Environment.default)
     p.expects(:friend_groups).returns(['group1', 'group2'])
     assert_equivalent [ 'friends', 'work', 'school', 'family', 'group1', 'group2' ], p.suggested_friend_groups
   end
 
   should 'accept nil friend groups when suggesting friend groups' do
-    p = Person.new(:environment => Environment.default)
+    p = build(Person, :environment => Environment.default)
     p.expects(:friend_groups).returns([nil])
     assert_equivalent [ 'friends', 'work', 'school', 'family' ], p.suggested_friend_groups
   end
@@ -309,29 +309,29 @@ class PersonTest < ActiveSupport::TestCase
   end
 
   should 'provide desired info fields' do 
-    p = Person.new(:environment => Environment.default)
+    p = build(Person, :environment => Environment.default)
     assert p.respond_to?(:photo)
     assert p.respond_to?(:address)
     assert p.respond_to?(:contact_information)
   end
 
   should 'required name' do
-    person = Person.new(:environment => Environment.default)
+    person = Person.new
     assert !person.valid?
-    assert person.errors[:name.to_s].present?
+    assert person.errors[:name].present?
   end
 
   should 'already request friendship' do
     p1 = create_user('testuser1').person
     p2 = create_user('testuser2').person
-    AddFriend.create!(:person => p1, :friend => p2)
+    create(AddFriend, :person => p1, :friend => p2)
     assert p1.already_request_friendship?(p2)
   end
 
   should 'have e-mail addresses' do
     env = fast_create(Environment)
-    env.domains <<  Domain.new(:name => 'somedomain.com')
-    person = Person.new(:environment => env, :identifier => 'testuser')
+    env.domains <<  build(Domain, :name => 'somedomain.com')
+    person = build(Person, :environment => env, :identifier => 'testuser')
     person.expects(:environment).returns(env)
 
     assert_equal ['testuser@somedomain.com'], person.email_addresses
@@ -339,9 +339,9 @@ class PersonTest < ActiveSupport::TestCase
 
   should 'not show www in e-mail addresses when force_www=true' do
     env = fast_create(Environment)
-    env.domains <<  Domain.new(:name => 'somedomain.com')
+    env.domains <<  build(Domain, :name => 'somedomain.com')
     env.update_attribute(:force_www, true)
-    person = Person.new(:environment => env, :identifier => 'testuser')
+    person = build(Person, :environment => env, :identifier => 'testuser')
     person.expects(:environment).returns(env)
 
     assert_equal ['testuser@somedomain.com'], person.email_addresses
@@ -366,7 +366,7 @@ class PersonTest < ActiveSupport::TestCase
   end
 
   should 'have a default person template' do
-    env = Environment.create!(:name => 'test env')
+    env = create(Environment, :name => 'test env')
     p = create_user('test_user', :environment => env).person
     assert_kind_of Person, p.template
   end
@@ -375,7 +375,7 @@ class PersonTest < ActiveSupport::TestCase
     p = create_user('test_profile').person
 
     assert_no_difference Task, :count do
-      Task.create(:requestor => p)
+      create(Task, :requestor => p)
       p.destroy
     end
   end
@@ -437,7 +437,7 @@ class PersonTest < ActiveSupport::TestCase
   should 'return active_person_fields' do
     e = Environment.default
     e.expects(:active_person_fields).returns(['cell_phone', 'comercial_phone']).at_least_once
-    person = Person.new(:environment => e)
+    person = build(Person, :environment => e)
 
     assert_equal e.active_person_fields, person.active_fields
   end
@@ -445,7 +445,7 @@ class PersonTest < ActiveSupport::TestCase
   should 'return email as active_person_fields' do
     e = Environment.default
     e.expects(:active_person_fields).returns(['nickname']).at_least_once
-    person = Person.new(:environment => e)
+    person = build(Person, :environment => e)
 
     assert_equal ['nickname', 'email'], person.active_fields
   end
@@ -453,7 +453,7 @@ class PersonTest < ActiveSupport::TestCase
   should 'return required_person_fields' do
     e = Environment.default
     e.expects(:required_person_fields).returns(['cell_phone', 'comercial_phone']).at_least_once
-    person = Person.new(:environment => e)
+    person = build(Person, :environment => e)
 
     assert_equal e.required_person_fields, person.required_fields
   end
@@ -461,7 +461,7 @@ class PersonTest < ActiveSupport::TestCase
   should 'require fields if person needs' do
     e = Environment.default
     e.expects(:required_person_fields).returns(['cell_phone']).at_least_once
-    person = Person.new(:environment => e)
+    person = build(Person, :environment => e)
     assert ! person.valid?
     assert person.errors[:cell_phone.to_s].present?
 
@@ -474,7 +474,7 @@ class PersonTest < ActiveSupport::TestCase
     e = Environment.default
     e.expects(:required_person_fields).returns(['area_of_study', 'custom_area_of_study']).at_least_once
   
-    person = Person.new(:environment => e, :area_of_study => 'Others')
+    person = build(Person, :environment => e, :area_of_study => 'Others')
     assert !person.valid?
     assert person.errors[:custom_area_of_study.to_s].present?
 
@@ -487,7 +487,7 @@ class PersonTest < ActiveSupport::TestCase
     e = Environment.default
     e.expects(:required_person_fields).returns(['area_of_study']).at_least_once
 
-    person = Person.new(:environment => e, :area_of_study => 'Agrometeorology')
+    person = build(Person, :environment => e, :area_of_study => 'Agrometeorology')
     person.valid?
     assert ! person.errors[:custom_area_of_study.to_s].present?
   end
@@ -496,7 +496,7 @@ class PersonTest < ActiveSupport::TestCase
     e = Environment.default
     e.expects(:required_person_fields).returns(['formation', 'custom_formation']).at_least_once
 
-    person = Person.new(:environment => e, :formation => 'Others')
+    person = build(Person, :environment => e, :formation => 'Others')
     assert !person.valid?
     assert person.errors[:custom_formation.to_s].present?
 
@@ -509,7 +509,7 @@ class PersonTest < ActiveSupport::TestCase
     e = Environment.default
     e.expects(:required_person_fields).returns(['formation']).at_least_once
  
-    person = Person.new(:environment => e, :formation => 'Agrometeorology')
+    person = build(Person, :environment => e, :formation => 'Agrometeorology')
     assert !person.valid?
     assert ! person.errors[:custom_formation.to_s].present?
   end
@@ -548,7 +548,7 @@ class PersonTest < ActiveSupport::TestCase
   should 'not ask to join if already asked' do
     p = create_user('test_user').person
     c = fast_create(Community)
-    AddMember.create!(:person => p, :organization => c)
+    create(AddMember, :person => p, :organization => c)
 
     assert !p.ask_to_join?(c)
   end
@@ -651,8 +651,8 @@ class PersonTest < ActiveSupport::TestCase
     p1.add_friend(p2)
     p2.add_friend(p1)
     p2.add_friend(p3)
-    assert_equal p2, Person.more_popular[0]
-    assert_equal p1, Person.more_popular[1]
+    assert_equal p2, Person.more_popular.all[0]
+    assert_equal p1, Person.more_popular.all[1]
   end
 
   should 'list people that have no friends in more popular list' do
@@ -1183,12 +1183,12 @@ class PersonTest < ActiveSupport::TestCase
     p2 = create_user('user2').person
     profile = fast_create(Profile)
 
-    abuse_report1 = AbuseReport.new(:reason => 'some reason')
+    abuse_report1 = build(AbuseReport, :reason => 'some reason')
     assert_difference AbuseComplaint, :count, 1 do
       p1.register_report(abuse_report1, profile)
     end
 
-    abuse_report2 = AbuseReport.new(:reason => 'some reason')
+    abuse_report2 = build(AbuseReport, :reason => 'some reason')
     assert_no_difference AbuseComplaint, :count do
       p2.register_report(abuse_report2, profile)
     end
@@ -1206,7 +1206,7 @@ class PersonTest < ActiveSupport::TestCase
     profile = fast_create(Profile)
     assert !person.already_reported?(profile)
 
-    person.register_report(AbuseReport.new(:reason => 'some reason'), profile)
+    person.register_report(build(AbuseReport, :reason => 'some reason'), profile)
     person.reload
     assert person.already_reported?(profile)
   end
@@ -1226,9 +1226,9 @@ class PersonTest < ActiveSupport::TestCase
     person = fast_create(Person)
     another_person = fast_create(Person)
 
-    scrap = Scrap.create!(defaults_for_scrap(:sender => another_person, :receiver => person, :content => 'A scrap'))
+    scrap = create(Scrap, defaults_for_scrap(:sender => another_person, :receiver => person, :content => 'A scrap'))
     UserStampSweeper.any_instance.expects(:current_user).returns(person).at_least_once
-    article = TinyMceArticle.create!(:profile => person, :name => 'An article about free software')
+    article = create(TinyMceArticle, :profile => person, :name => 'An article about free software')
 
     assert_equivalent [scrap,article.activity], person.activities.map { |a| a.klass.constantize.find(a.id) }
   end
@@ -1237,14 +1237,14 @@ class PersonTest < ActiveSupport::TestCase
     person = fast_create(Person)
     another_person = fast_create(Person)
 
-    person_scrap = Scrap.create!(defaults_for_scrap(:sender => person, :receiver => person, :content => 'A scrap from person'))
-    another_person_scrap = Scrap.create!(defaults_for_scrap(:sender => another_person, :receiver => another_person, :content => 'A scrap from another person'))
+    person_scrap = create(Scrap, defaults_for_scrap(:sender => person, :receiver => person, :content => 'A scrap from person'))
+    another_person_scrap = create(Scrap, defaults_for_scrap(:sender => another_person, :receiver => another_person, :content => 'A scrap from another person'))
 
-    TinyMceArticle.create!(:profile => another_person, :name => 'An article about free software from another person')
+    create(TinyMceArticle, :profile => another_person, :name => 'An article about free software from another person')
     another_person_activity = ActionTracker::Record.last
 
     UserStampSweeper.any_instance.stubs(:current_user).returns(person)
-    TinyMceArticle.create!(:profile => person, :name => 'An article about free software')
+    create(TinyMceArticle, :profile => person, :name => 'An article about free software')
     person_activity = ActionTracker::Record.last
 
     assert_equivalent [person_scrap,person_activity], person.activities.map { |a| a.klass.constantize.find(a.id) }
@@ -1288,7 +1288,7 @@ class PersonTest < ActiveSupport::TestCase
 
   should 'define abuser?' do
     abuser = create_user('abuser').person
-    AbuseComplaint.create!(:reported => abuser).finish
+    create(AbuseComplaint, :reported => abuser).finish
     person = create_user('person').person
 
     assert abuser.abuser?
@@ -1297,21 +1297,21 @@ class PersonTest < ActiveSupport::TestCase
 
   should 'be able to retrieve abusers and non abusers' do
     abuser1 = create_user('abuser1').person
-    AbuseComplaint.create!(:reported => abuser1).finish
+    create(AbuseComplaint, :reported => abuser1).finish
     abuser2 = create_user('abuser2').person
-    AbuseComplaint.create!(:reported => abuser2).finish
+    create(AbuseComplaint, :reported => abuser2).finish
     person = create_user('person').person
 
     abusers = Person.abusers
 
-    assert_equal ActiveRecord::NamedScope::Scope, abusers.class
+    assert_equal ActiveRecord::Relation, abusers.class
     assert_includes abusers, abuser1
     assert_includes abusers, abuser2
     assert_not_includes abusers, person
 
     non_abusers = Person.non_abusers
 
-    assert_equal ActiveRecord::NamedScope::Scope, non_abusers.class
+    assert_equal ActiveRecord::Relation, non_abusers.class
     assert_not_includes non_abusers, abuser1
     assert_not_includes non_abusers, abuser2
     assert_includes non_abusers, person
@@ -1319,9 +1319,9 @@ class PersonTest < ActiveSupport::TestCase
 
   should 'not return canceled complaints as abusers' do
     abuser = create_user('abuser1').person
-    AbuseComplaint.create!(:reported => abuser).finish
+    create(AbuseComplaint, :reported => abuser).finish
     not_abuser = create_user('abuser2').person
-    AbuseComplaint.create!(:reported => not_abuser).cancel
+    create(AbuseComplaint, :reported => not_abuser).cancel
 
     abusers = Person.abusers
     assert_includes abusers, abuser
diff --git a/vendor/plugins/action_tracker/lib/action_tracker.rb b/vendor/plugins/action_tracker/lib/action_tracker.rb
index 083f771..b22f6f0 100644
--- a/vendor/plugins/action_tracker/lib/action_tracker.rb
+++ b/vendor/plugins/action_tracker/lib/action_tracker.rb
@@ -74,7 +74,7 @@ module ActionTracker
       end
 
       def acts_as_trackable(options = {})
-        has_many :tracked_actions, { :class_name => "ActionTracker::Record", :order => "updated_at DESC", :foreign_key => :user_id }.merge(options)
+        has_many :tracked_actions, { :class_name => "ActionTracker::Record", :order => "updated_at DESC", :foreign_key => :user_id, :dependent => :destroy }.merge(options)
         send :include, InstanceMethods
       end
     end
--
libgit2 0.21.2