Paper Trail Gem: Track Changes to Your

Models Data

Howdy, today I am going to talk about the versioning. How to specifically version your models? So wondering what I am talking about? What is that versioning and my models?

Let me explain you with an example.

If you have created a specific document that many people can edit; yes, just similar to Google Docs. Let’s say, it’s a client proposal and you want your colleagues to do have a look and if required then make the validate changes. After sharing the document with your colleagues, in case someone does @#$%***&% to your doc or if someone has updated your doc with the required changes, then you will not be able to see all the previous versions of the doc and who changed it. This is the most common scenario as it creates a big mess.

How To Track changes to your models’ data

To help you out and track all the changes as well as who has done this, we’re going to use Paper Trail gem. It is a simplified version of Google Docs. A very, very simplified. This gem lets you track all the changes, as the purpose of editing and versioning.

And making use of it, you can be able to see all the previous versions of the file and if required you can rollback to a previous version of your choice. You can even undo all the changes after a record has been destroyed so as to restore it completely.

Why Paper trail?

It’s a one stop solution for text data:It helps to focus on what to look for. Helps to focus on auditing or versioning.Relevant data is split across directories, multiple apps and systems. So instead of source, they can be managed by username, IP address, message ID.

Setup The App

I am not going to build the application from scratch. Instead have pulled the code from Github.Git clone : https://github.com/

Run the migration, bundle and start the app

rake db:migratebundle installrails server

If you head over to localhost:3000, you should see the following :

PaperTrail

PaperTrail to automatically keep track of what happened to our documents.

# Gemfile gem 'paper_trail'

Now, 3 steps in one line to get it to work :

bundle install && bundle exec rails generate paper_trail:install && bundle exec rake db:migrate

Restart your server before continuing.

After that, add PaperTrail to the model we want to version :

# app/models/document.rbclass Document < ActiveRecord::Base

belongs_to :user

has_paper_trail

def user_name user ? user.name : '‘

end end

And that’s it ! Everytime we save our model, we’ll get the previous version saved by PaperTrail :

PaperTrail::Version.all

# => #<ActiveRecord::Relation [#<PaperTrail::Version id: 1, item_type: "Document", item_id: 1, event: "update", whodunnit: "1", object: "---\nid: 1\nname: Abcz\ncontent: aaa\nuser_id: 1\ncreat...", created_at: "2014-09-26 15:38:14">]>

Listing the previous versions

# app/helpers/documents_helper.rbmodule DocumentsHelper

def find_version_author_name(version)

user = User.find_version_author(version)

user ? user.name : '' end

end

# app/models/user.rbclass User < ActiveRecord::Base

has_many :documents def

self.find_version_author(version) find(version.terminator)

endend

Now, let’s add the actual list of versions to the edit document view as a partial :

Ruby:

And render this partial after the Document form :

# app/views/documents/edit.html.erb... <%= render 'form' %><%= render 'documents/versions‘

,document: @document %>

Now you can udpate any document a few times. You should see the list of versions growing!

Add Diff & Rollback

First, we’re going to update the edit document view to add action to the links :

Then we need the routes :

# config/routes.rbresources :documents doresources :versions, only: [:destroy] do

member doget :diff, to: 'versions#diff‘

patch :rollback, to: 'versions#rollback‘end

end end

You can also rollback to a previous version! Pretty cool, huh! So for that we’re going to use the very nice gem Diffy. Diffy gives us an easy way to diff content (files or strings) in Ruby by using Unix diff.

And finally, we create the controller :

Diff with Diffy

Add the gem to your Gemfile :

# Gemfile...

gem 'paper_trail‘gem 'diffy‘...

bundle install and restart your server.

Now the actual diff view is pretty simple to build. We’re going to create it in app/ views/ versions/ :

If you try it, you should see something like that:.

Very nice! Now, our app is missing one veryimportant feature. Its a way to bring backdocuments from the graveyard!

Custom Version Class

Adding a custom version class is actually quite easy.First, we need to generate a migration :

rails g migration create_document_versions

You can paste this in it :

The corresponding model:

Note the default_scope I added.

Bring back Documents

The actions in our controllers:

And a view to list the deleted documents :

# app/views/documents/deleted.html.erb

Bring back documents

Now try it! Delete a document and it will appear in the list of deleted

MetaDataRemember when we created the migration for you custom Document Version model ? We’re going to use those!

# app/models/document.rb...

has_paper_trail class_name: 'DocumentVersion', meta: { author_username: :user_name,

word_count: :count_word }

When PaperTrail generate a new version, it will call the defined methods (user_name) on document an save it in the specified field (author_username).

We need to add a method named count_word.

def count_wordcontent.split(' ').count

enddef count_word

content.split(' ').countend

And since we added all those information, we should show it in our list of versions.

And save a few versions to see the metadata!

Who needs 100 versions ?The last trick, We probably don’t need the 100 previous versions, 10 to 30 should be enough. You can define that in PaperTrail configuration :

# config/initializers/paper_trail.rbPaperTrail.config.version_limit = 10

Source code -https://github.com/airblade/paper_trail#1c-basic-usage

Features:

1.Stores every update and destroy.2.Only store updates that has been changed.3.You can have all the version, including the

original, if it even destroyed once.4.You can get every version even if the schema

has since changed.5.Automatically record a responsible controller

current user method.6.Allows you to set who is responsible at model-

level (useful for migrations).7.No configuration necessary.8.Can be turned off/on.9.Everything can be stored in a single database

table.10.Thoroughly tested.

Interested in installation

Bacancy Technology has been providing ruby on rails development services from past 5 years. We own a strong ROR workforce and have successfully completed 200+ Rails Application.

Our developers have in-depth knowledge and skilful expertise in doing all kinds of Ruby on Rails development work and dealing with any kind of project.

Numbers of big organizations have made their way to the top using Rails, and possibly you can be the next, with the help of Ruby on Rails.