auditable 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use 1.9.3@auditable

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in auditable.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Harley Trung
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,152 @@
+# Auditable
+
+There are a lot of gems under https://www.ruby-toolbox.com/categories/Active_Record_Versioning and https://www.ruby-toolbox.com/categories/Active_Record_User_Stamping but there are various issues with them (as of this writing):
+
+* Almost all of them are outdated and not working with Rails 3.2.2. Some of the popular ones such as `papertrail` and `vestal_versions` have many issues and pull requests but haven't been addressed or merged. Based on the large number of forks of these popular gems, people seem to be OK with their own gem tweaks. Some tweaks are good, but some are too hackish (to deal with recent Rails changes) based on the commits that I have read. I have tried some of the more popular ones but they don't work reliably for something simple I'm trying to achieve.
+* Many of these gems have evolved overtime and become rather (very) cumbersome.
+* Most or all of them don't seem to support beyond the database columns, i.e. not working (or working well) with virtual methods or associations. `papertrail` supports `has_one` but the author said it's not easy to go further than that.
+* I need something simple and lightweight.
+
+A lot of the gems in the above category are great. I'm just aiming to create a dead simple gem that lets you easily diff the changes on a model's attributes or methods. Yes, methods, not just attributes. Here's the key difference in my approach:
+
+If you want to track changes to complicated stuff such as associated records, just define a method that returns some representation of the associated records and let `auditable` keeps track of the changes in those values over time.
+
+Basically:
+
+* I don't want the default to track all my columns. Only the attributes or methods I specify please.
+* I don't want to deal with association mess. Use methods instead.
+* I care about tracking the values of certain virtual attributes or methods, not just database columns
+* I want something simple, similar to [ActiveRecord::Dirty#changes](http://ar.rubyonrails.org/classes/ActiveRecord/Dirty.html#M000291) but persistent across saves. See `Auditable::Auditing#audited_changes` below.
+
+See examples under Usage section.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'auditable'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install auditable
+
+## Usage
+
+First, add the necessary `audits` table to your database with:
+
+    rails generate auditable:migration
+    rake db:migrate
+
+Then, provide a list of methods you'd like to audit to the `audit` method in your model.
+
+    class Survey
+      has_many :questions
+      attr_accessor :current_page
+
+      audit :title, :current_page, :question_ids
+    end
+
+## Demo
+
+I'm going to demo with the test models from the test suite. You probably want to use 'rails console' and test with the model that you want to audit.
+
+For more details, I suggest you check out the test examples in the `spec` folder itself.
+
+    $ bundle console
+    >> require(File.expand_path "../spec/spec_helper", __FILE__)
+    => true
+
+    >> s = Survey.create :title => "demo"
+    => #<Survey id: 1, title: "demo">
+
+    >> Survey.audited_attributes
+    => [:title, :current_page]
+
+    >> s.audited_changes
+    => {"title"=>[nil, "demo"]}
+
+    >> s.update_attributes(:title => "new title", :current_page => 2)
+    => true
+
+    >> s.audited_changes
+    => {"title"=>["demo", "new title"], "current_page"=>[nil, 2]}
+
+    >> s.update_attributes(:current_page => 3, :action => "modified", :changed_by => User.create(:name => "someone"))
+    => true
+
+    >> s.audited_changes
+    => {"current_page"=>[2, 3]}
+
+    >> s.audits.last
+    => #<Auditable::Audit id: 3, auditable_id: 1, auditable_type: "Survey", user_id: 1, user_type: "User", modifications: {"title"=>"new title", "current_page"=>3}, action: "modified", created_at: ...>
+
+    >> s.tag_with(:tag => "something memorable")
+       # we just tagged the latest audit, now then do make changes with s
+       # ...
+       # assuming you've made some changes to s
+
+    >> s.audited_changes(:tag => "something memorable")
+       # return the changes against the tagged version above
+       # note s.audited_changes still diff against the second latest audit
+       # you can also pass in other filters, such as s.audited_changes(:changed_by => some_user, :audit_action => "modified")
+       # note that it always uses the latest audit to diff against an earlier audit matching the arguments to audited_changes
+
+## How it works
+### Audit Model
+
+As seen above, I intend to have a migration file like this for the Audit model:
+
+    class CreateAudits < ActiveRecord::Migration
+      def change
+        create_table :audits do |t|
+          t.belongs_to :auditable, :polymorphic => true
+          t.belongs_to :user, :polymorphic => true
+          t.text :modifications
+          t.string :action
+          t.timestamps
+        end
+      end
+    end
+
+It guessable from the above that `audits.modifications` will just be a serialized representation of keys and values of the audited attributes.
+
+### Who changed it and what was that action?
+
+If you want to store the user who made the changed to the record, just assigned it to the record's `changed_by` attribute, like so:
+
+    # note you have to define `attr_accessor :changed_by` yourself
+    >> @survey.update_attributes(:changed_by => current_user, # and other attributes you want to set)
+    # then @surveys.audits.last.user will be set to current_user
+    # also works when you set changed_by and call save later, of course
+
+`action` will just be `create` or `update` depending on the operation on the record, but you can also override it with another virtual attribute, call it `change_action`
+
+    >> @survey.changed_action = "add page"
+    >> @survey.update_attribute :page_count, 2
+
+**Don't store a new row in `audits` table if the `modifications` column is the same as the one immediately before it. This makes it easier to review change**
+
+That's all I can do for this README Driven approach. Back soon.
+
+## TODO
+
+* improve api (still clumsy) -- come up with better syntax
+* get some suggestions and feedback
+* update README
+
+e.g. right now, changes are serialized into `audits.modifications` column, but what if we what to do multiple sets of audits at each save. I'm thinking of supporting syntax like this:
+
+    # store snapshots of certain methods to audits.trivial_changes column (that you can easily add yourself)
+    audit :modifications => [:method_1, :method_2], :trivial_changes => [:method_3, :method_4, :method_5]
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:rspec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rspec_opts = ['-cfs --backtrace']
+end
+
+desc "Default: run specs"
+task :default => :rspec
+
+

data/auditable.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/auditable/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Harley Trung"]
+  gem.email         = ["harley@socialsci.com"]
+  gem.description   = %q{A simple gem that audit models' attributes or methods by taking snapshots and diff them for you. Starting from scratch to work with Rails 3.2.2 onwards}
+  gem.summary       = %q{A simple gem to audit attributes and methods in ActiveRecord models.}
+  gem.homepage      = ""
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "auditable"
+  gem.require_paths = ["lib"]
+  gem.version       = Auditable::VERSION
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'watchr'
+  gem.add_development_dependency 'sqlite3'
+  # documetation stuff
+  gem.add_development_dependency 'yard'
+  gem.add_development_dependency 'rdiscount'
+
+  gem.add_runtime_dependency 'activesupport'
+  gem.add_runtime_dependency 'activerecord'
+end

data/generators/auditable/migration_generator.rb

@@ -0,0 +1,27 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Auditable
+  module Generators
+    class MigrationGenerator < ::Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      def self.source_root
+        @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+      end
+
+      # Rails expects us to override/implement this ourself
+      def self.next_migration_number(dirname)
+        if ActiveRecord::Base.timestamped_migrations
+          Time.new.utc.strftime("%Y%m%d%H%M%S")
+        else
+          "%.3d" % (current_migration_number(dirname) + 1)
+        end
+      end
+
+      def generate_files
+        migration_template 'migration.rb', 'db/migrate/create_audits.rb'
+      end
+    end
+  end
+end

data/generators/auditable/templates/migration.rb

@@ -0,0 +1,12 @@
+class CreateAudits < ActiveRecord::Migration
+  def change
+    create_table :audits do |t|
+      t.belongs_to :auditable, :polymorphic => true
+      t.belongs_to :user, :polymorphic => true
+      t.text :modifications
+      t.string :action
+      t.string :tag
+      t.timestamps
+    end
+  end
+end

data/lib/auditable.rb

@@ -0,0 +1,8 @@
+require 'active_record'
+require 'active_support/concern'
+
+require "auditable/version"
+require 'auditable/audit'
+require 'auditable/auditing'
+
+ActiveRecord::Base.send :include, Auditable::Auditing

data/lib/auditable/audit.rb

@@ -0,0 +1,66 @@
+module Auditable
+  class Audit < ActiveRecord::Base
+    belongs_to :auditable, :polymorphic => true
+    belongs_to :user, :polymorphic => true
+    serialize :modifications
+
+    # Diffing two audits' modifications
+    #
+    # Returns a hash containing arrays of the form
+    #   {
+    #     :key_1 => [<value_in_other_audit>, <value_in_this_audit>],
+    #     :key_2 => [<value_in_other_audit>, <value_in_this_audit>],
+    #     :other_audit_own_key => [<value_in_other_audit>, nil],
+    #     :this_audio_own_key  => [nil, <value_in_this_audit>]
+    #   }
+    def diff(other_audit)
+      other_modifications = other_audit ? other_audit.modifications : {}
+
+      {}.tap do |d|
+        # find keys present only in this audit
+        (self.modifications.keys - other_modifications.keys).each do |k|
+          d[k] = [nil, self.modifications[k]] if self.modifications[k]
+        end
+
+        # find keys present only in other audit
+        (other_modifications.keys - self.modifications.keys).each do |k|
+          d[k] = [other_modifications[k], nil] if other_modifications[k]
+        end
+
+        # find common keys and diff values
+        self.modifications.keys.each do |k|
+          if self.modifications[k] != other_modifications[k]
+            d[k] = [other_modifications[k], self.modifications[k]]
+          end
+        end
+      end
+    end
+
+    # Diff this audit with the one created immediately before it
+    #
+    # See #diff for more details
+    def latest_diff(options = {})
+      if options.present?
+        scoped = auditable.audits.order("created_at DESC")
+        if tag = options.delete(:tag)
+          scoped = scoped.where(:tag => tag)
+        end
+        if changed_by = options.delete(:changed_by)
+          scoped = scoped.where(:user_id => changed_by.id, :user_type => changed_by.class.name)
+        end
+        if audit_tag = options.delete(:audit_tag)
+          scoped = scoped.where(:tag => audit_tag)
+        end
+        diff scoped.first
+      else
+        diff_since(created_at)
+      end
+    end
+
+    # Diff this audit with the latest audit created before the `time` variable passed
+    def diff_since(time)
+      other_audit = self.class.where("created_at < ?", time).order("created_at DESC").limit(1).first
+      diff(other_audit)
+    end
+  end
+end

data/lib/auditable/auditing.rb

@@ -0,0 +1,71 @@
+#require 'active_support/concern'
+
+module Auditable
+  module Auditing
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      attr_writer :audited_attributes
+
+      # Get the list of methods to track over record saves, including those inherited from parent
+      def audited_attributes
+        attrs =  @audited_attributes || []
+        # handle STI case: include parent's audited_attributes
+        if superclass != ActiveRecord::Base and superclass.respond_to?(:audited_attributes)
+          attrs.push(*superclass.audited_attributes)
+        end
+        attrs
+      end
+
+      # Set the list of methods to track over record saves
+      #
+      # Example:
+      #
+      #   class Survey < ActiveRecord::Base
+      #     audit :page_count, :question_ids
+      #   end
+      def audit(*options)
+        has_many :audits, :class_name => "Auditable::Audit", :as => :auditable
+        after_create {|record| record.snap!("create")}
+        after_update {|record| record.snap!("update")}
+
+        self.audited_attributes = Array.wrap options
+      end
+    end
+
+    # INSTANCE METHODS
+
+    # Get the latest audit record
+    def last_audit
+      audits.last
+    end
+
+    # Mark the latest record in order to easily find and perform diff against later
+    def tag_with(tag)
+      last_audit.update_attribute(:tag, tag)
+    end
+
+    # Take a snapshot of and save the current state of the audited record's audited attributes
+    def snap!(action_default = "update")
+      snap = {}.tap do |s|
+        self.class.audited_attributes.each do |attr|
+          s[attr.to_s] = self.send attr
+        end
+      end
+      audits.create! do |audit|
+        audit.modifications = snap
+        audit.tag = self.audit_tag if self.respond_to?(:audit_tag)
+        audit.action = (self.respond_to?(:audit_action) && self.audit_action) || action_default
+        audit.user = self.changed_by if self.respond_to?(:changed_by)
+      end
+    end
+
+    # Get the latest changes by comparing the latest two audits
+    def audited_changes(options = {})
+      audits.last.latest_diff(options)
+    end
+
+    #def self.included(base)
+    #end
+  end
+end

data/lib/auditable/version.rb

@@ -0,0 +1,3 @@
+module Auditable
+  VERSION = "0.0.1"
+end

data/spec/lib/auditable_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe "Model.audited_attributes" do
+  it "should be available to models using audit" do
+    Survey.audited_attributes.should include :title
+  end
+end
+
+describe Auditable do
+  let(:survey) { Survey.create :title => "test survey" }
+  let(:user) { User.create(:name => "test user") }
+  let(:another_user) { User.create(:name => "another user") }
+
+  it "should have a valid audit to start with" do
+    survey.title.should == "test survey"
+    survey.audited_changes.should == {"title" => [nil, "test survey"]}
+    survey.audits.last.action.should == "create"
+  end
+
+  it "should behave similar to ActiveRecord::Dirty#changes" do
+    # first, let's see how ActiveRecord::Dirty#changes behave
+    survey.title = "new title"
+    survey.changes.should == {"title" => ["test survey", "new title"]}
+    survey.save!
+    survey.changes.should == {}
+    # .audited_changes to the rescue:
+    survey.audited_changes.should == {"title" => ["test survey", "new title"]}
+    survey.audits.last.action.should == "update"
+  end
+
+  it "should handle virtual attributes" do
+    survey.current_page = 1
+    # ActiveRecord::Dirty#changes is not meant to track virtual attributes
+    survey.changes.should == {}
+    survey.save!
+    # but we do because we were told to track it
+    survey.audited_changes.should == {"current_page" => [nil, 1]}
+  end
+
+  it "should handle multiple keys" do
+    survey.current_page = 1
+    survey.title = "new title"
+    survey.save
+    survey.audited_changes.should == {
+      "title" => ["test survey", "new title"],
+      "current_page" => [nil, 1]
+    }
+  end
+
+  context "setting additional attributes" do
+    it "should set changed_by" do
+      survey.update_attributes(:title => "another title", :changed_by => user)
+      survey.audits.last.user.should == user
+    end
+
+    it "should set audit_action" do
+      survey.update_attributes(:audit_action => "modified")
+      survey.audits.last.action.should == "modified"
+    end
+
+    it "should set audit_tag" do
+      survey.update_attributes(:audit_tag => "some tag")
+      survey.audits.last.tag.should == "some tag"
+    end
+  end
+
+  describe ".last_audit" do
+    it "should be the same as audits.last" do
+      survey.audits.last.should == survey.last_audit
+    end
+  end
+
+  context "tagging" do
+    describe ".tag_with" do
+      it "should tag the latest audit" do
+        survey.audits.last.tag.should_not == "hey"
+        survey.tag_with("hey")
+        survey.audits.last.tag.should == "hey"
+      end
+    end
+
+    describe ".audited_changes" do
+      context "using :tag and :changed_by arguments" do
+        before do
+          survey.tag_with("original")
+          survey.update_attributes :title => "new title 1", :changed_by => user
+          survey.tag_with("locked")
+          survey.update_attributes :title => "new title 2", :changed_by => another_user
+          survey.tag_with("locked")
+          survey.update_attributes :title => "new title 3", :changed_by => user
+          survey.update_attributes :title => "new title 4", :changed_by => another_user
+        end
+
+        it "should diff with latest audit matching a tag" do
+          survey.audited_changes(:tag => "original").should == {"title" => ["test survey", "new title 4"]}
+          survey.audited_changes(:tag => "locked").should == {"title" => ["new title 2", "new title 4"]}
+        end
+
+        it "should diff with latest audit matching user" do
+          survey.audited_changes(:changed_by => user).should == {"title" => ["new title 3", "new title 4"]}
+        end
+
+        it "should diff under the same user and tag" do
+          survey.audited_changes(:tag => "locked", :changed_by => user).should == {"title" => ["new title 1", "new title 4"]}
+        end
+      end
+    end
+  end
+
+  context "distinguishing between audited records" do
+    let(:another_survey) { Survey.create :title => "another survey" }
+    it "should audit changes pertaining to each record only" do
+      survey.update_attributes :title => "new title 1"
+      another_survey.update_attributes :title => "another title 1"
+      survey.audited_changes.should == {"title" => ["test survey", "new title 1"]}
+      another_survey.audited_changes.should == {"title" => ["another survey", "another title 1"]}
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'bundler'
+Bundler.require
+
+require 'auditable'
+
+Dir[File.expand_path("../support/*.rb", __FILE__)].each {|f| require f}

data/spec/support/models.rb

@@ -0,0 +1,24 @@
+class Survey < ActiveRecord::Base
+  attr_accessor :current_page
+  attr_accessor :changed_by, :audit_action, :audit_tag
+
+  audit :title, :current_page
+end
+
+class User < ActiveRecord::Base
+end
+
+# TODO add Question class to give examples on association stuff
+
+# prepare test data
+class CreateTestSchema < ActiveRecord::Migration
+  def change
+    create_table "surveys", :force => true do |t|
+      t.string "title"
+    end
+    create_table "users", :force => true do |t|
+      t.string "name"
+    end
+  end
+end
+

data/spec/support/schema.rb

@@ -0,0 +1,10 @@
+ActiveRecord::Base.establish_connection({
+  :adapter  => 'sqlite3',
+  :database => ':memory:'
+})
+
+CreateTestSchema.migrate(:up)
+
+# run gem's required migration
+require(File.expand_path("../../../generators/auditable/templates/migration.rb", __FILE__))
+CreateAudits.migrate(:up)

data/specs.watchr

@@ -0,0 +1,61 @@
+# Run me with:
+#
+#   $ watchr specs.watchr
+
+# --------------------------------------------------
+# Convenience Methods
+# --------------------------------------------------
+def all_spec_files
+  Dir['spec/**/*_spec.rb']
+end
+
+def run_spec_matching(thing_to_match)
+  matches = all_spec_files.grep(/#{thing_to_match}/i)
+  if matches.empty?
+    puts "Sorry, thanks for playing, but there were no matches for #{thing_to_match}"
+  else
+    run matches.join(' ')
+  end
+end
+
+def run(files_to_run)
+  puts("Running: #{files_to_run}")
+  system("clear;rspec #{files_to_run}")
+  no_int_for_you
+end
+
+def run_all_specs
+  run(all_spec_files.join(' '))
+end
+
+# --------------------------------------------------
+# Watchr Rules
+# --------------------------------------------------
+watch('^spec/(.*)_spec\.rb')   { |m| run_spec_matching(m[1]) }
+watch('^lib/(.*)\.rb')         { |m| run_spec_matching(m[1]) }
+watch('^lib/(.*)/.*\.rb')         { |m| run_spec_matching(m[1]) }
+watch('^spec/spec_helper\.rb') { run_all_specs }
+watch('^spec/support/.*\.rb')   { run_all_specs }
+
+# --------------------------------------------------
+# Signal Handling
+# --------------------------------------------------
+
+def no_int_for_you
+  @sent_an_int = nil
+end
+
+Signal.trap 'INT' do
+  if @sent_an_int then
+    puts "   A second INT?  Ok, I get the message.  Shutting down now."
+    exit
+  else
+    puts "   Did you just send me an INT? Ugh.  I'll quit for real if you do it again."
+    @sent_an_int = true
+    Kernel.sleep 1.5
+    run_all_specs
+  end
+end
+
+# vim:ft=ruby
+

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: auditable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Harley Trung
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2157976740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157976740
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2157976240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157976240
+- !ruby/object:Gem::Dependency
+  name: watchr
+  requirement: &2157975760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157975760
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &2157975300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157975300
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &2157974760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157974760
+- !ruby/object:Gem::Dependency
+  name: rdiscount
+  requirement: &2157974220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157974220
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2157973780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157973780
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &2157973340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157973340
+description: A simple gem that audit models' attributes or methods by taking snapshots
+  and diff them for you. Starting from scratch to work with Rails 3.2.2 onwards
+email:
+- harley@socialsci.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- auditable.gemspec
+- generators/auditable/migration_generator.rb
+- generators/auditable/templates/migration.rb
+- lib/auditable.rb
+- lib/auditable/audit.rb
+- lib/auditable/auditing.rb
+- lib/auditable/version.rb
+- spec/lib/auditable_spec.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+- spec/support/schema.rb
+- specs.watchr
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1046713668439752865
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1046713668439752865
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: A simple gem to audit attributes and methods in ActiveRecord models.
+test_files:
+- spec/lib/auditable_spec.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+- spec/support/schema.rb
+has_rdoc: