rollbacker 1.0.0 → 1.0.1

data/README.md

@@ -1,16 +1,121 @@
-## Rollbacker ##
+Rollbacker
+==========
 
-Rollbacker is a manage tool for auditing changes to your ActiveRecord.
+**Rollbacker** is a manage tool for auditing changes to your ActiveRecord.
 The changes of objects are added to a queue where the auditor can approve and reject those changes.
 
-## Installation ##
+## Installation
 
 To use it with your Rails 3 project, add the following line to your Gemfile
 
-  gem 'rollbacker'
+```ruby
+gem 'rollbacker'
+```
 
 Generate the migration and create the rollbacker_changes table
+```bash
+$ rails generate rollbacker:migration
+$ rake db:migrate
+```
+
+## Usage
+
+Simply call `rollbacker` on your models:
+
+```ruby
+class Model < ActiveRecord::Base
+  rollbacker(:create, :update, :destroy)
+end
+```
+
+After that, whenever a model is created, updated or destroyed, a new RollbackerChange record is created.
+
+```ruby
+# Create Model
+> Model.count
+=> 0
+> Model.create(name: 'Name', value: 'Value')
+=> #<Model id: nil, name: "Name", value: "Value">
+> Model.count
+=> 0
+> RollbackerChange.last.approve
+> Model.count
+=> 1
+
+# Update Model
+> m = Model.first
+=> #<Model id: 1, name: "Name", value: "Value">
+> m.update_attribute(:name, 'New')
+> m.reload
+=> #<Model id: 1, name: "Name", value: "Value">
+> m.rollbacker_changes.last.rollbacked_changes
+=> {"name"=>["Name", "New"]}
+> m.update_attributes(:name=>'Newer', :value => 'New')
+> m.rollbacker_changes.last.rollbacked_changes
+=> {"name"=>["Name", "Newer"], "value"=>["Value", "New"]}
+> m.rollbacker_changes.last.approve('value')
+> m.reload
+=> #<Model id: 1, name: "Name", value: "New">
+> m.rollbacker_changes.last.rollbacked_changes
+=> {"name"=>["Name", "Newer"]}
+> m.rollbacker_changes.last.reject
+> m.reload
+=> #<Model id: 1, name: "Name", value: "New">
+
+# Destroy Model
+> m.destroy
+> Model.count
+=> 1
+> m.rollbacker_changes.last.approve
+> Model.count
+=> 0
+```
+
+The rollbacked_changes column automatically serializes the changes of any model attributes modified during the action. If there are only a few attributes you want to track or a couple that you want to prevent from being tracked, you can specify that in the rollbacker call. For example
+```ruby
+rollbacker(:create, :destroy, :except => [:title])
+rollbacker(:update, :only => :title)
+```
+
+### Current User Tracking
+
+If you're using Rollbacker in a Rails application, all changes made within a request will automatically be attributed to the current user. By default, Rollbacker uses the `current_user` method in your controller.
+
+```ruby
+class PostsController < ApplicationController
+  def create
+    current_user # => #<User name: "Steve">
+    @post = Post.create(params[:post])
+    @post.rollbacker_changes.last.user # => #<User name: "Steve">
+  end
+end
+```
+
+### Integration
+There may be some instances where you need to perform an action on your model object without Rollbacker. In those cases you can include the Rollbacker::Status module for help.
+```ruby
+class PostsController < ApplicationController
+  include Rollbacker::Status
+
+  def update
+    post = Post.find(params[:id])
+    without_rollbacker { post.update_attributes(params[:post]) } # Rollbacker is disabled for the entire block
+  end
+end
+```
+
+You can also force Rollbacker to track any actions within a block as a specified user.
+```ruby
+class PostsController < ApplicationController
+  include Rollbacker::Status
+
+  def update
+    post = Post.find(params[:id])
+    rollbacker_as(another_user) { post.update_attributes(params[:post]) }
+  end
+end
+```
+
+For more details, I suggest you check out the test examples in the spec folder itself.
 
-  rails generate rollbacker:migration
-  rake db:migrate
 

data/lib/rollbacker/base.rb

@@ -23,7 +23,7 @@ module Rollbacker
 
         config = Rollbacker::Config.new(*args)
         config.actions.each do |action|
-          send "around_#{action}", Rollbacker::DatabaseRollback.new(config.options)
+          send "before_#{action}", Rollbacker::DatabaseRollback.new(config.options)
           # send :after_rollback, Rollbacker::Recorder.new(action, config.options, &blk), :on => action
         end
         send :after_rollback, Rollbacker::Recorder.new(config.options, &blk)

data/lib/rollbacker/database_rollback.rb

@@ -10,7 +10,7 @@ module Rollbacker
     end
 
     [:create, :update, :destroy].each do |action|
-      define_method("around_#{action}") do |model|
+      define_method("before_#{action}") do |model|
         rollback_model_changes(model, action)
       end
     end

data/lib/rollbacker/rollbacker_change.rb

@@ -1,7 +1,9 @@
 require 'active_record'
 require 'rollbacker/config'
+require 'rollbacker/status'
 
 class RollbackerChange < ActiveRecord::Base
+  include Rollbacker::Status
   belongs_to :rollbackable, :polymorphic => true
   belongs_to :user, :polymorphic => true
 
@@ -9,14 +11,65 @@ class RollbackerChange < ActiveRecord::Base
 
   serialize :rollbacked_changes
 
-  def new_attributes
+  def new_attributes(*fields)
     (rollbacked_changes || {}).inject({}.with_indifferent_access) do |attrs,(attr,values)|
       attrs[attr] = values.is_a?(Array) ? values.last : values
       attrs
+    end.select do |k,v|
+      fields.blank? ? true : fields.map(&:to_s).include?(k)
     end
   end
 
+
+  def reject(*fields)
+    without_rollbacker do
+      case self.action.to_s
+      when 'update', 'create'
+        update_changes_after_approve_or_reject(*fields)
+      when 'destroy'
+        self.rollbacked_changes = nil
+        self.destroy
+      end
+    end
+  end
+
+  def approve(*fields)
+    without_rollbacker do
+      edits = self.new_attributes(*fields)
+      case self.action.to_s
+      when 'update'
+        if edits.present? && self.rollbackable && self.rollbackable.update_attributes(edits)
+          update_changes_after_approve_or_reject(*fields)
+          return true
+        end
+      when 'create'
+        if edits.present? && self.rollbackable_type.constantize.create(edits)
+          self.rollbacked_changes = nil
+          self.destroy
+        end
+      when 'destroy'
+        if self.rollbackable && self.rollbackable.destroy
+          self.rollbacked_changes = nil
+          self.destroy
+        end
+      end
+    end
+  end
+
+  def create_action?;   self[:action].to_s == 'create'   end
+  def update_action?;   self[:action].to_s == 'update'   end
+  def destroy_action?;  self[:action].to_s == 'destroy'  end
+
 private
+  def update_changes_after_approve_or_reject(*fields)
+    edits = fields.blank? ? nil : rollbacked_changes.delete_if{|k,v| fields.map(&:to_s).include?(k) }
+    if edits.present?
+      self.update_attribute(:rollbacked_changes, edits)
+    else
+      self.rollbacked_changes = nil
+      self.destroy
+    end
+  end
 
   def set_user
     self.user = Rollbacker::User.current_user if self.user_id.nil?

data/lib/rollbacker/version.rb

@@ -1,3 +1,3 @@
 module Rollbacker
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/spec/database_rollback_spec.rb

@@ -11,11 +11,11 @@ describe Rollbacker::DatabaseRollback do
   end
 
   [:create, :update, :destroy].each do |action|
-    it "should respond with around_#{action}" do
+    it "should respond with before_#{action}" do
       model = Model.new(name: 'name')
       config     = Rollbacker::Config.new(action)
       callback = Rollbacker::DatabaseRollback.new(config.options)
-      callback.should respond_to("around_#{action}")
+      callback.should respond_to("before_#{action}")
     end
   end
 
@@ -27,7 +27,7 @@ describe Rollbacker::DatabaseRollback do
 
     lambda {
       without_rollbacker do
-        callback.send :around_create, model
+        callback.send :before_create, model
       end
     }.should_not raise_exception(ActiveRecord::Rollback)
   end
@@ -39,7 +39,7 @@ describe Rollbacker::DatabaseRollback do
     callback = Rollbacker::DatabaseRollback.new(config.options)
 
     lambda {
-      callback.send :around_create, model
+      callback.send :before_create, model
     }.should raise_exception(ActiveRecord::Rollback)
   end
 end

data/spec/rollbacker_change_spec.rb

@@ -15,5 +15,284 @@ describe RollbackerChange do
     record = RollbackerChange.create(:rollbackable => @rollbackable, :user => @user, :action => :create)
     record.user.should == @user
   end
+
+  describe '#new_attributes' do
+    it "should collect all new values" do
+      record = RollbackerChange.new(rollbacked_changes: {'name'=>[nil, 'Name'], 'value'=>[nil, 'Value']})
+      record.new_attributes.should == {'name'=>'Name','value'=>'Value'}
+    end
+
+    it "should select only specific attributes" do
+      record = RollbackerChange.new(rollbacked_changes: {'name'=>[nil, 'Name'], 'value'=>[nil, 'Value']})
+      record.new_attributes('name').should == {'name'=>'Name'}
+      record.new_attributes(:name).should == {'name'=>'Name'}
+    end
+  end
+
+  describe '#update_changes_after_approve_or_reject' do
+    it "should remove edits from rollbacked_changes field" do
+      record = RollbackerChange.new(rollbacked_changes: {'name'=>[nil, 'Name'], 'value'=>[nil, 'Value']})
+      record.send(:update_changes_after_approve_or_reject, 'name')
+      record.rollbacked_changes.should == {'value'=>[nil, 'Value']}
+      record.should_not be_destroyed
+    end
+
+    it "should be able update multiple fields" do
+      record = RollbackerChange.new(rollbacked_changes: {'name'=>[nil, 'Name'], 'value'=>[nil, 'Value']})
+      record.send(:update_changes_after_approve_or_reject, 'name', 'value')
+      record.rollbacked_changes.should be_nil
+      record.should be_destroyed
+    end
+
+    it "should destroy record and remove all changes with no arguments" do
+      record = RollbackerChange.new(rollbacked_changes: {'name'=>[nil, 'Name'], 'value'=>[nil, 'Value']})
+      record.send(:update_changes_after_approve_or_reject)
+      record.rollbacked_changes.should be_nil
+      record.should be_destroyed
+    end
+
+    it "should destroy record if no more changes" do
+      record = RollbackerChange.create(rollbacked_changes: {'name'=>[nil, 'Name']})
+      record.send(:update_changes_after_approve_or_reject, 'name')
+      record.rollbacked_changes.should be_nil
+      record.should be_destroyed
+    end
+
+    it "should destroy record if no more changes" do
+      record = RollbackerChange.create(rollbacked_changes: {'name'=>[nil, 'Name']})
+      record.send(:update_changes_after_approve_or_reject, :name)
+      record.rollbacked_changes.should be_nil
+      record.should be_destroyed
+    end
+  end
+
+  describe "reject" do
+    context "on :update" do
+      let(:action) { :update }
+      it "should not change anything with a has no change about the field" do
+        record = RollbackerChange.create({
+          :rollbacked_changes => {'name'=>[nil, 'Name']},
+          :rollbackable       => @rollbackable,
+          :user               => @user,
+          :action             => action
+        })
+        record.rollbackable.should be_present
+        record.should be_update_action
+        lambda {
+          record.reject('value').should be_true
+        }.should_not change(RollbackerChange, :count)
+        record.reload.rollbacked_changes.should == {'name'=>[nil, 'Name']}
+      end
+      it "should NOT apply the change to the auditable model" do
+        record = RollbackerChange.create({
+          :rollbacked_changes => {'name'=>[nil, 'Name'], 'value'=>[nil, 'Value']},
+          :rollbackable       => @rollbackable,
+          :user               => @user,
+          :action             => action
+        })
+        record.rollbackable.should be_present
+        record.should be_update_action
+        lambda {
+          record.reject('name').should be_true
+        }.should_not change(RollbackerChange, :count)
+        @rollbackable.reload.name.should be_nil
+        record.rollbacked_changes.should == {'value'=>[nil, 'Value']}
+        record.should_not be_destroyed
+      end
+    end
+
+    context "on :create" do
+      let(:action) { :create }
+      it "should NOT be created if has no change about the field" do
+        record = RollbackerChange.create({
+          :rollbacked_changes => {'name'=>[nil, 'Name']},
+          :rollbackable_type  => 'Model',
+          :user               => @user,
+          :action             => action
+        })
+        record.should be_create_action
+        lambda {
+          lambda {
+            record.reject('value').should be_true
+          }.should_not change(RollbackerChange, :count)
+        }.should_not change(Model, :count)
+        record.reload.rollbacked_changes.should == {'name'=>[nil, 'Name']}
+      end
+      it "should be able to only update changes without insert a new record" do
+        record = RollbackerChange.create({
+          :rollbacked_changes => {'name'=>[nil, 'Name'], 'value'=>[nil, 'Value']},
+          :rollbackable_type  => 'Model',
+          :user               => @user,
+          :action             => action
+        })
+        record.should be_create_action
+        lambda {
+          lambda {
+            record.reject('value').should be_true
+          }.should_not change(RollbackerChange, :count)
+        }.should_not change(Model, :count)
+        record.reload.rollbacked_changes.should == {'name'=>[nil, 'Name']}
+      end
+    end
+    context "on :destroy" do
+      let(:action) { :destroy }
+      it "should only remove rollbacker_change record and discart rollbacked_changes" do
+        record = RollbackerChange.create({
+          :rollbacked_changes => {'name'=>[nil, 'Name'], 'value'=>[nil, 'Value']},
+          :rollbackable       => @rollbackable,
+          :user               => @user,
+          :action             => action
+        })
+        record.rollbackable.should be_present
+        record.should be_destroy_action
+        lambda {
+          lambda {
+            record.reject.should be_true
+          }.should change(RollbackerChange, :count).by(-1)
+        }.should_not change(Model, :count)
+        @rollbackable.reload.name.should  be_nil
+        @rollbackable.reload.value.should be_nil
+        record.rollbacked_changes.should  be_nil
+        record.should be_destroyed
+      end
+    end
+  end
+
+  describe "approve" do
+    context "on :update" do
+      let(:action) { :update}
+      it "should not change anything with a has no change about the field" do
+        record = RollbackerChange.create({
+          :rollbacked_changes => {'name'=>[nil, 'Name']},
+          :rollbackable       => @rollbackable,
+          :user               => @user,
+          :action             => action
+        })
+        record.rollbackable.should be_present
+        record.should be_update_action
+        lambda {
+          lambda {
+            record.approve('value').should be_nil
+          }.should_not change(RollbackerChange, :count)
+        }.should_not change(Model, :count)
+        record.reload.rollbacked_changes.should == {'name'=>[nil, 'Name']}
+      end
+      it "should apply the change to the auditable model from a specific field" do
+        record = RollbackerChange.create({
+          :rollbacked_changes => {'name'=>[nil, 'Name'], 'value'=>[nil, 'Value']},
+          :rollbackable       => @rollbackable,
+          :user               => @user,
+          :action             => action
+        })
+        record.rollbackable.should be_present
+        record.should be_update_action
+        lambda {
+          lambda {
+            record.approve('name').should be_true
+          }.should_not change(RollbackerChange, :count)
+        }.should_not change(Model, :count)
+        @rollbackable.reload.name.should == 'Name'
+        record.reload.rollbacked_changes.should == {'value'=>[nil, 'Value']}
+        record.should_not be_destroyed
+      end
+      it "should apply all changes to the auditable model" do
+        record = RollbackerChange.create({
+          :rollbacked_changes => {'name'=>[nil, 'Name'], 'value'=>[nil, 'Value']},
+          :rollbackable       => @rollbackable,
+          :user               => @user,
+          :action             => action
+        })
+        record.rollbackable.should be_present
+        record.should be_update_action
+        lambda {
+          lambda {
+            record.approve.should be_true
+          }.should change(RollbackerChange, :count).by(-1)
+        }.should_not change(Model, :count)
+        @rollbackable.reload.name.should == 'Name'
+        @rollbackable.reload.value.should == 'Value'
+        record.rollbacked_changes.should be_nil
+        record.should be_destroyed
+      end
+    end
+
+    context "on :create" do
+      let(:action) { :create }
+      it "should not change anything with a has no change about the field" do
+        record = RollbackerChange.create({
+          :rollbacked_changes => {'name'=>[nil, 'Name']},
+          :rollbackable_type  => 'Model',
+          :user               => @user,
+          :action             => action
+        })
+        record.should be_create_action
+        lambda {
+          lambda {
+            record.approve('value').should be_nil
+          }.should_not change(RollbackerChange, :count)
+        }.should_not change(Model, :count)
+        record.reload.rollbacked_changes.should == {'name'=>[nil, 'Name']}
+      end
+      it "should be created a rollbackable model from specific fields" do
+        record = RollbackerChange.create({
+          :rollbacked_changes => {'name'=>[nil, 'Newer Name'], 'value'=>[nil,'Newer Value']},
+          :rollbackable_type  => 'Model',
+          :user               => @user,
+          :action             => action
+        })
+        record.should be_create_action
+        lambda {
+          lambda {
+            record.approve('name').should be_true
+          }.should change(RollbackerChange, :count).by(-1)
+        }.should change(Model, :count).by(1)
+        record.rollbacked_changes.should be_nil
+        record.should be_destroyed
+        rollbackable = Model.last
+        rollbackable.name.should == 'Newer Name'
+        rollbackable.value.should be_nil
+      end
+      it "should be created a rollbackable model with all fields" do
+        record = RollbackerChange.create({
+          :rollbacked_changes => {'name'=>[nil, 'Name'], 'value'=>[nil,'Value']},
+          :rollbackable_type  => 'Model',
+          :user               => @user,
+          :action             => action
+        })
+        record.should be_create_action
+        lambda {
+          lambda {
+            record.approve.should be_true
+          }.should change(RollbackerChange, :count).by(-1)
+        }.should change(Model, :count).by(1)
+        record.rollbacked_changes.should be_nil
+        record.should be_destroyed
+        rollbackable = Model.last
+        rollbackable.name.should == 'Name'
+        rollbackable.value.should == 'Value'
+      end
+    end
+    context "on :destroy" do
+      let(:action) { :destroy }
+      it "should not change anything with a has no change about the field" do
+        record = RollbackerChange.create({
+          :rollbacked_changes => nil,
+          :rollbackable       => @rollbackable,
+          :user               => @user,
+          :action             => action
+        })
+        record.rollbackable.should be_present
+        record.should be_destroy_action
+        lambda {
+          lambda {
+            record.approve.should be_true
+          }.should change(RollbackerChange, :count).by(-1)
+        }.should change(Model, :count).by(-1)
+        record.rollbacked_changes.should == nil
+        record.should be_destroyed
+        @rollbackable.should be_destroyed
+      end
+    end
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rollbacker
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -140,3 +140,4 @@ test_files:
 - spec/support/model_setup.rb
 - spec/support/transactional_specs.rb
 - spec/user_spec.rb
+has_rdoc: